Helper class to help Components define the material properties the Physics may need from the parameters specified by the user Note: Trying out virtual inheritance. More...

#include <ComponentMaterialPropertyInterface.h>

Inheritance diagram for ComponentMaterialPropertyInterface:

[legend]

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

Public Member Functions
	ComponentMaterialPropertyInterface (const InputParameters &params)

bool	hasProperty (const std::string &property_name) const
	Whether the component has a property with that name.

const MooseFunctorName &	getPropertyValue (const std::string &property_name, const std::string &requestor_name) const
	Return the name of the functor for that property.

virtual void	act () override final
	Method to add objects to the simulation or perform other setup tasks.

const std::vector< MeshGeneratorName > &	meshGeneratorNames () const
	Get the name(s) of the mesh generator(s) created by this component that generates the mesh for it.

MeshGeneratorName	getCurrentTopLevelMeshGeneratorName () const
	Return the name of the final mesh generator that contains this component This may not be one of the mesh generators of the component.

void	setCurrentTopLevelMeshGeneratorName (const MeshGeneratorName &mg_name)
	Set the name of the final mesh generator that contains this component.

const std::vector< SubdomainName > &	blocks () const
	Returns the subdomains for the component mesh, if any.

virtual const std::vector< BoundaryName > &	outerSurfaceBoundaries () const
	Return the outer surface boundaries.

virtual Real	volume () const
	Return the component volume.

virtual Real	outerSurfaceArea () const
	Return the component outer boundary area.

unsigned int	dimension () const
	Return the dimension of the component.

void	addConnectedComponent (ActionComponent &component)
	Merge another component's group into this component's group.

const std::set< ActionComponent * > &	getConnectedComponents () const
	Get all components connected to the component group of this component (including itself)

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

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)
	Method to add a relationship manager for the objects being added to the system.

MooseObjectName	uniqueActionName () const
	The unique name for accessing input parameters of this action in the InputParameterWarehouse.

const std::string &	specificTaskName () const

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

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with.

const std::string &	type () const
	Get the type of this class.

const std::string &	name () const
	Get the name of the class.

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const
	Get the parameters of the object.

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object.

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object.

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

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.

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

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.

bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default.

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

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

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

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

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError().

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.

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

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning().

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

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

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

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method.

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.

PerfGraph &	perfGraph ()
	Get the PerfGraph.

void	assertParamDefined (const std::string &libmesh_dbg_var(param)) const

Static Public Member Functions
static InputParameters	validParams ()

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

Public Attributes
	usingCombinedWarningSolutionWarnings

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

Static Public Attributes
static const std::string	unique_action_name_param = "_unique_action_name"
	The name of the parameter that contains the unique action name.

static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

static constexpr auto	SYSTEM = "MeshMetaData"
	The system name used when initializing the Restartable interface.

static constexpr auto	NAME = "<empty>"
	The data name used when initializing the Restartable interface for non-MeshGenerator objects.

Protected Member Functions
virtual void	addMaterials () override
	Used to add materials or functor materials on a component.

virtual void	addMeshGenerators ()

virtual void	addPositionsObject ()

virtual void	addUserObjects ()

virtual void	setupComponent ()

virtual void	addSolverVariables ()
	Used to add variables on a component.

virtual void	addPhysics ()
	Used to add one or more Physics to be active on the component.

virtual void	checkIntegrity ()
	Used for various checks notably:

virtual void	actOnAdditionalTasks ()
	Use this if registering a new task to the derived ActionComponent.

void	addRequiredTask (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.

void	checkRequiredTasks () const
	Checks that tasks marked required by parent classes are indeed registered to derived classes.

FEProblemBase &	getProblem ()
	Get problem from action warehouse.

Factory &	getFactory () const
	Get the factory to build (often physics-related but not always) objects (for example a Positions)

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
	Method to add a relationship manager for the objects being added to the system.

void	associateWithParameter (const std::string &param_name, InputParameters &params) const
	Associates the object's parameters `params` with the input location from this Action's parameter with the name `param_name`, if one exists.

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
	The same as associateWithParameter() without `from_params`, but instead allows you to associate this with another object's parameters instead of the parameters from this action.

template<typename T >
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
	Method for retrieving a property with the given type and name exists in the mesh meta-data store.

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

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

template<typename T >
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

template<typename T >
bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.

std::string	timedSectionName (const std::string &section_name) const

template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.

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

void	assertParamDefined (const std::string &param) const
	Check in debug mode that this parameter has been added to the validParams.

void	checkParamsBothSetOrNotSet (const std::string &param1, const std::string &param2) const
	Check that two parameters are either both set or both not set.

void	checkSecondParamSetOnlyIfFirstOneTrue (const std::string &param1, const std::string &param2) const
	Check that a parameter is set only if the first one is set to true.

void	checkSecondParamSetOnlyIfFirstOneSet (const std::string &param1, const std::string &param2) const
	Check that a parameter is set only if the first one is set.

void	checkSecondParamNotSetIfFirstOneSet (const std::string &param1, const std::string &param2) const
	Check that a parameter is not set if the first one is set.

void	checkVectorParamsSameLength (const std::string &param1, const std::string &param2) const
	Check that the two vector parameters are of the same length.

void	checkVectorParamAndMultiMooseEnumLength (const std::string &param1, const std::string &param2) const
	Check that this vector parameter (with name defined in `param1`) has the same length as the MultiMooseEnum (with name defined in `param2`)

void	checkTwoDVectorParamsSameLength (const std::string &param1, const std::string &param2) const
	Check that the two-D vectors have exactly the same length in both dimensions.

void	checkVectorParamsNoOverlap (const std::vector< std::string > &param_vecs) const
	Check that there is no overlap between the items in each vector parameters Each vector parameter should also have unique items.

void	checkTwoDVectorParamsNoRespectiveOverlap (const std::vector< std::string > &param_vecs) const
	Check that there is no overlap between the respective items in each vector of the two-D parameters Each vector of the two-D vector parameter should also have unique items.

void	checkTwoDVectorParamInnerSameLengthAsOneDVector (const std::string &param1, const std::string &param2) const
	Check that each inner vector of a two-D vector parameter are the same size as another one-D vector parameter.

void	checkTwoDVectorParamMultiMooseEnumSameLength (const std::string &param1, const std::string &param2, const bool error_for_param2) const
	Check that the size of a two-D vector parameter matches the size of a MultiMooseEnum parameter.

void	checkVectorParamNotEmpty (const std::string &param1) const
	Check that the user did not pass an empty vector.

void	checkVectorParamsSameLengthIfSet (const std::string &param1, const std::string &param2, const bool ignore_empty_default_param2=false) const
	Check that two vector parameters are the same length if both are set.

void	checkVectorParamLengthSameAsCombinedOthers (const std::string &param1, const std::string &param2, const std::string &param3) const
	Check that a vector parameter is the same length as two others combined.

void	checkBlockwiseConsistency (const std::string &block_param_name, const std::vector< std::string > &parameter_names) const
	Check if the user commited errors during the definition of block-wise parameters.

bool	parameterConsistent (const InputParameters &other_param, const std::string &param_name) const
	Return whether two parameters are consistent.

void	warnInconsistent (const InputParameters &parameters, const std::string &param_name) const
	Emits a warning if two parameters are not equal to each other.

void	errorDependentParameter (const std::string &param1, const std::string &value_not_set, const std::vector< std::string > &dependent_params) const
	Error messages for parameters that should depend on another parameter.

void	errorInconsistentDependentParameter (const std::string &param1, const std::string &value_set, const std::vector< std::string > &dependent_params) const
	Error messages for parameters that should depend on another parameter but with a different error message.

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

Protected Attributes
const std::vector< std::string >	_property_names
	Names of the material properties.

const std::vector< MooseFunctorName >	_property_functors
	Functor values of the material properties.

const bool	_use_ad_for_props
	Whether to use automatic differentiation when defining properties.

unsigned int	_dimension
	Maximum dimension of the component.

std::vector< MeshGeneratorName >	_mg_names
	Name(s) of the final mesh generator(s) creating the mesh for the component.

MeshGeneratorName	_top_mg_name
	Name of the top-most mesh generator in the hierarchy of MGs on top of the ones generating this component.

std::vector< SubdomainName >	_blocks
	Names of the blocks the component is comprised of.

std::vector< BoundaryName >	_outer_boundaries
	Names of the boundaries on the component outer surface.

const bool	_verbose
	Whether the component setup should be verbose.

std::set< std::string >	_required_tasks
	Manually keeps track of the tasks required by each component as tasks cannot be inherited.

std::shared_ptr< std::set< ActionComponent * > >	_connected_components
	Group of components that share a common mesh after junctioning.

std::string	_registered_identifier

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

std::set< std::string >	_all_tasks
	A list of all the tasks that this Action will satisfy.

ActionWarehouse &	_awh
	Reference to ActionWarehouse where we store object build by actions.

const std::string &	_current_task
	The current action (even though we have separate instances for each action)

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem
	Convenience reference to a problem this action works on.

PerfID	_act_timer
	Timers.

MooseApp &	_app
	The MOOSE application this is associated with.

Factory &	_factory
	The Factory associated with the MooseApp.

ActionFactory &	_action_factory
	Builds Actions.

const std::string &	_type
	The type of this class.

const std::string &	_name
	The name of this class.

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.

const std::string	_prefix
	A prefix to use for all sections.

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
	Method for adding a single relationship manager.

virtual std::string	meshPropertyPrefix (const std::string &data_name) const
	The default prefix to use for getting/seeing if mesh properties exist.

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
	Helper for getting a mesh property.

template<typename... Args>
void	mooseErrorInternal (Args &&... args) const
	Helper for forwarding a mooseError to an object's mooseError if it is available (said error will provide more context: object name and type)

const T &	forwardGetParam (const std::string &param_name) const
	Forwards parameter check to the class using this utility.

const InputParameters &	forwardParameters () const
	Forwards obtaining parameters to the class using this utility.

bool	forwardIsParamSetByUser (const std::string &param_name) const
	Forwards parameter check to the class using this utility.

bool	forwardIsParamValid (const std::string &param_name) const
	Forwards parameter check to the class using this utility.

void	forwardParamError (Args &&... args) const
	Forwards error to the class using this utility to get better error messages.

void	forwardMooseError (Args &&... args) const
	Forwards error to the class using this utility to get better error messages.

void	forwardMooseWarning (Args &&... args) const
	Forwards warning to the class using this utility to get better error messages.

const std::string &	forwardType () const
	Get the type of the class using this utility.

virtual const std::string &	forwardName () const
	Get the name of the class using this utility.

const std::vector< SubdomainName > &	forwardBlocks () const
	Get the blocks for the class using this utility.

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app
	Reference to the application.

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

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

const ActionComponent *const	_customer_class

Detailed Description

Helper class to help Components define the material properties the Physics may need from the parameters specified by the user Note: Trying out virtual inheritance.

It makes things a little easier to define as we can use the attributes of the underlying ActionComponent

Definition at line 23 of file ComponentMaterialPropertyInterface.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

◆ ComponentMaterialPropertyInterface()

ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface ( const InputParameters & params )

Definition at line 44 of file ComponentMaterialPropertyInterface.C.

  : ActionComponent(params),
    _property_names(getParam<std::vector<std::string>>("property_names")),
    _property_functors(getParam<std::vector<MooseFunctorName>>("property_values")),
    _use_ad_for_props(getParam<bool>("use_ad_for_properties"))
{
  addRequiredTask("add_material");
  if (_property_names.size() != _property_functors.size())
    paramError("property_names", "Should be the same size as property functors");
}

Member Function Documentation

◆ act()

void ActionComponent::act ( )

finaloverridevirtualinherited

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

Implements Action.

Definition at line 39 of file ActionComponent.C.

{
  // This is inspired by the PhysicsBase definition of act(). We register components to the
  // task they use, and the base class calls the appropriate virtual member functions
  mooseDoOnce(checkRequiredTasks());
 
  // These tasks are conceptually what we imagine a mostly-geometrical component should do
  if (_current_task == "add_mesh_generator")
    addMeshGenerators();
  else if (_current_task == "add_positions")
    addPositionsObject();
  else if (_current_task == "add_user_object")
    addUserObjects();
  else if (_current_task == "setup_component")
    setupComponent();
  // If we define the Physics in a Physics block. See PhysicsComponentBase
  else if (_current_task == "init_component_physics")
    addPhysics();
  // These tasks are there to match what the current combined Physics + Component do
  // These combined components will likely still exist in the future, when it makes more
  // sense to include the physics than to split it off into its own block
  else if (_current_task == "add_variable")
    addSolverVariables();
  // Useful for declaring materials on a component, which helps keep the input of local material
  // properties on the component
  else if (_current_task == "add_material")
    addMaterials();
  else if (_current_task == "check_integrity")
    checkIntegrity();
  else
    // For a new task that isn't registered to ActionComponent in the framework
    actOnAdditionalTasks();
}

◆ actOnAdditionalTasks()

virtual void ActionComponent::actOnAdditionalTasks ( )

inlineprotectedvirtualinherited

Use this if registering a new task to the derived ActionComponent.

Definition at line 98 of file ActionComponent.h.

98{}

Referenced by ActionComponent::act().

◆ addConnectedComponent()

void ActionComponent::addConnectedComponent ( ActionComponent & component )

inherited

Merge another component's group into this component's group.

The group is shared (via a shared_ptr) by every component in it, so a single call connects both sides.

Definition at line 91 of file ActionComponent.C.

{
  // Already in the same group
  if (_connected_components == component._connected_components)
    return;
 
  // Hold a reference to the other group before we re-point its members
  auto other_group = component._connected_components;
  _connected_components->insert(other_group->begin(), other_group->end());
 
  // Every former member of the other group now shares this group's set
  for (auto * member : *other_group)
    member->_connected_components = _connected_components;
}

◆ addMaterials()

void ComponentMaterialPropertyInterface::addMaterials ( )

overrideprotectedvirtual

Used to add materials or functor materials on a component.

Reimplemented from ActionComponent.

Definition at line 57 of file ComponentMaterialPropertyInterface.C.

{
  if (getParam<bool>("define_material_properties") && _property_names.size())
  {
    // Add a material that makes material properties available on the blocks of the component.
    // The idea is to make the values/functors available under the same property name across all
    // components. Then the Physics / kernels can just use the name of the property
    InputParameters params = getFactory().getValidParams("MaterialFunctorConverter");
    params.set<std::vector<SubdomainName>>("block") = _blocks;
 
    // Type conversion
    std::vector<MaterialPropertyName> property_names(_property_names.size());
    std::transform(_property_names.begin(),
                   _property_names.end(),
                   property_names.begin(),
                   [](const std::string & val) { return MaterialPropertyName(val); });
    if (_use_ad_for_props)
      params.set<std::vector<MaterialPropertyName>>("ad_props_out") = property_names;
    else
      params.set<std::vector<MaterialPropertyName>>("reg_props_out") = property_names;
    params.set<std::vector<MooseFunctorName>>("functors_in") = _property_functors;
    getProblem().addMaterial(
        "MaterialFunctorConverter", name() + "_local_material_properties", params);
  }
 
  // Add a functor material that makes the functor material properties on the blocks of the
  // component. This makes the functors available under the same functor name across all components
  if (getParam<bool>("define_functor_properties") && _property_names.size())
  {
    // Add a material that makes material properties available on the blocks of the component.
    // The idea is to make the values/functors available under the same property name across all
    // components. Then the Physics / kernels can just use the name of the property
    const auto mat_type = _use_ad_for_props ? "ADGenericFunctorMaterial" : "GenericFunctorMaterial";
    InputParameters params = getFactory().getValidParams(mat_type);
    params.set<std::vector<SubdomainName>>("block") = _blocks;
    params.set<std::vector<std::string>>("prop_names") = _property_names;
    params.set<std::vector<MooseFunctorName>>("prop_values") = _property_functors;
    getProblem().addMaterial(mat_type, name() + "_local_functor_properties", params);
  }
}

◆ addMeshGenerators()

virtual void ActionComponent::addMeshGenerators ( )

inlineprotectedvirtualinherited

Reimplemented in ComponentJunction, ComponentMeshTransformHelper, CylinderComponent, and MeshGeneratorComponent.

Definition at line 80 of file ActionComponent.h.

80{}

Referenced by ActionComponent::act().

◆ addPhysics()

virtual void ActionComponent::addPhysics ( )

inlineprotectedvirtualinherited

Used to add one or more Physics to be active on the component.

We recommend using the PhysicsComponentInterface instead of overriding this directly

Reimplemented in ComponentPhysicsInterface.

Definition at line 90 of file ActionComponent.h.

90{}

Referenced by ActionComponent::act().

◆ addPositionsObject()

virtual void ActionComponent::addPositionsObject ( )

inlineprotectedvirtualinherited

Definition at line 81 of file ActionComponent.h.

81{}

Referenced by ActionComponent::act().

◆ addRelationshipManager()

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

privateinherited

Method for adding a single relationship manager.

Parameters

input_rm_type	What relationship manager type we are currently adding
moose_object_pars	The parameters of the MooseObject that requested the RM
rm_name	The class type of the RM, e.g. ElementSideNeighborLayers
rm_type	The RelationshipManagerType, e.g. geometric, algebraic, coupling
rm_input_parameter_func	The RM callback function, typically a lambda defined in the requesting MooseObject's validParams function
sys_type	A RMSystemType that can be used to limit the systems and consequent dof_maps that the RM can be attached to

Returns: Whether a relationship manager was added

Definition at line 100 of file Action.C.

{
  // These need unique names
  static unsigned int unique_object_id = 0;
 
  auto new_name = moose_object_pars.getBase() + '_' + name() + '_' + rm_name + "_" +
                  Moose::stringify(rm_type) + " " + std::to_string(unique_object_id);
 
  auto rm_params = _factory.getValidParams(rm_name);
  rm_params.set<Moose::RelationshipManagerType>("rm_type") = rm_type;
 
  rm_params.set<std::string>("for_whom") = name();
 
  // If there is a callback for setting the RM parameters let's use it
  if (rm_input_parameter_func)
    rm_input_parameter_func(moose_object_pars, rm_params);
 
  rm_params.set<MooseMesh *>("mesh") = _mesh.get();
 
  if (!rm_params.areAllRequiredParamsValid())
    mooseError("Missing required parameters for RelationshipManager " + rm_name + " for object " +
               name());
 
  auto rm_obj = _factory.create<RelationshipManager>(rm_name, new_name, rm_params);
 
  const bool added = _app.addRelationshipManager(rm_obj);
 
  // Delete the resources created on behalf of the RM if it ends up not being added to the App.
  if (!added)
    _factory.releaseSharedObjects(*rm_obj);
  else // we added it
    unique_object_id++;
 
  return added;
}

Referenced by Action::addRelationshipManagers().

◆ addRelationshipManagers() [1/2]

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

virtualinherited

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

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

Parameters

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

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

Definition at line 143 of file Action.C.

144{

145}

◆ addRelationshipManagers() [2/2]

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

protectedinherited

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

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

Parameters

when_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 148 of file Action.C.

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

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

◆ addRequiredTask()

void ActionComponent::addRequiredTask ( 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 102 of file ActionComponent.h.

102{ _required_tasks.insert(task); }

ActionComponent::_required_tasks

std::set< std::string > _required_tasks

Manually keeps track of the tasks required by each component as tasks cannot be inherited.

Definition ActionComponent.h:135

Referenced by ComponentBoundaryConditionInterface::ComponentBoundaryConditionInterface(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentJunction::ComponentJunction(), ComponentMaterialPropertyInterface(), ComponentMeshTransformHelper::ComponentMeshTransformHelper(), ComponentPhysicsInterface::ComponentPhysicsInterface(), CylinderComponent::CylinderComponent(), and MeshGeneratorComponent::MeshGeneratorComponent().

◆ addSolverVariables()

virtual void ActionComponent::addSolverVariables ( )

inlineprotectedvirtualinherited

Used to add variables on a component.

Definition at line 87 of file ActionComponent.h.

87{}

Referenced by ActionComponent::act().

◆ addUserObjects()

virtual void ActionComponent::addUserObjects ( )

inlineprotectedvirtualinherited

Definition at line 82 of file ActionComponent.h.

82{}

Referenced by ActionComponent::act().

◆ appendTask()

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

inlineinherited

Definition at line 114 of file Action.h.

114{ _all_tasks.insert(task); }

Action::_all_tasks

std::set< std::string > _all_tasks

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

Definition Action.h:166

◆ assertParamDefined() [1/2]

void InputParametersChecksUtils< ActionComponent >::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.");
}

◆ assertParamDefined() [2/2]

void InputParametersChecksUtils< ActionComponent >::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

◆ associateWithParameter() [1/2]

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

protectedinherited

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

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

Definition at line 176 of file Action.C.

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

◆ associateWithParameter() [2/2]

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

protectedinherited

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

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

Definition at line 170 of file Action.C.

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

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

◆ blocks()

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

inlineinherited

Returns the subdomains for the component mesh, if any.

Definition at line 50 of file ActionComponent.h.

50{ return _blocks; }

Referenced by PhysicsBase::addComponent(), DiffusionPhysicsBase::addInitialConditions(), and MeshGeneratorComponent::setupComponent().

◆ callMooseError() [1/2]

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

staticinherited

External method for calling moose error with added object context.

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

Parameters

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
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 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, show_trace);
}

◆ callMooseError() [2/2]

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

inherited

External method for calling moose error with added object context.

Parameters

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
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

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

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

◆ checkBlockwiseConsistency()

void InputParametersChecksUtils< ActionComponent >::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 120 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] + "'!");
      }
    }
  }
}

◆ checkIntegrity()

virtual void ActionComponent::checkIntegrity ( )

inlineprotectedvirtualinherited

Used for various checks notably:

that all ICs in a ComponentInitialConditionInterface are used

Reimplemented in ComponentBoundaryConditionInterface, ComponentInitialConditionInterface, ComponentJunction, CylinderComponent, and MeshGeneratorComponent.

Definition at line 95 of file ActionComponent.h.

95{}

Referenced by ActionComponent::act().

◆ checkParamsBothSetOrNotSet()

void InputParametersChecksUtils< ActionComponent >::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 40 of file InputParametersChecksUtils.h.

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

◆ checkRequiredTasks()

void ActionComponent::checkRequiredTasks ( ) const

protectedinherited

Checks that tasks marked required by parent classes are indeed registered to derived classes.

Definition at line 74 of file ActionComponent.C.

{
  const auto registered_tasks = _action_factory.getTasksByAction(type());
 
  // Check for missing tasks
  for (const auto & required_task : _required_tasks)
    if (!registered_tasks.count(required_task))
      mooseWarning(
          "Task '" + required_task +
          "' has been declared as required by a Component parent class of derived class '" +
          type() +
          "' but this task is not registered to the derived class. Registered tasks for "
          "this Component are: " +
          Moose::stringify(registered_tasks));
}

Referenced by ActionComponent::act().

◆ checkSecondParamNotSetIfFirstOneSet()

void InputParametersChecksUtils< ActionComponent >::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 54 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< ActionComponent >::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 49 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< ActionComponent >::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 44 of file InputParametersChecksUtils.h.

{
  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< ActionComponent >::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 87 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< ActionComponent >::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 93 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< ActionComponent >::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 82 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< ActionComponent >::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 71 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<S>>(param2).size())
      checkParamsBothSetOrNotSet(param1, param2);
}

◆ checkVectorParamAndMultiMooseEnumLength()

void InputParametersChecksUtils< ActionComponent >::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 65 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< ActionComponent >::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 112 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< ActionComponent >::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 99 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< ActionComponent >::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 77 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< ActionComponent >::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 60 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<S>>(param2).size())
      checkParamsBothSetOrNotSet(param1, param2);
}

◆ checkVectorParamsSameLengthIfSet()

void InputParametersChecksUtils< ActionComponent >::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 104 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 77 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);
    }
  }
}

◆ dimension()

unsigned int ActionComponent::dimension ( ) const

inlineinherited

Return the dimension of the component.

Definition at line 65 of file ActionComponent.h.

65{ return _dimension; }

ActionComponent::_dimension

unsigned int _dimension

Maximum dimension of the component.

Definition ActionComponent.h:118

Referenced by ComponentJunction::addMeshGenerators().

◆ errorDependentParameter()

void InputParametersChecksUtils< ActionComponent >::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 137 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< ActionComponent >::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 144 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 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ flagInvalidSolutionInternal()

template<bool warning>

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

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

{
  mooseAssert(
      warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
      "Inconsistent warning flag");
  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
  if constexpr (!warning)
    if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
      solution_invalidity.printDebug(invalid_solution_id);
  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
}

◆ forwardBlocks()

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

inlineprivateinherited

Get the blocks for the class using this utility.

Definition at line 192 of file InputParametersChecksUtils.h.

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

◆ forwardGetParam()

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

inlineprivateinherited

Forwards parameter check to the class using this utility.

Definition at line 153 of file InputParametersChecksUtils.h.

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

◆ forwardIsParamSetByUser()

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

inlineprivateinherited

Forwards parameter check to the class using this utility.

Definition at line 160 of file InputParametersChecksUtils.h.

  {
    return _customer_class->isParamSetByUser(param_name);
  }

◆ forwardIsParamValid()

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

inlineprivateinherited

Forwards parameter check to the class using this utility.

Definition at line 165 of file InputParametersChecksUtils.h.

  {
    return _customer_class->isParamValid(param_name);
  }

◆ forwardMooseError()

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

inlineprivateinherited

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

Definition at line 177 of file InputParametersChecksUtils.h.

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

◆ forwardMooseWarning()

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

inlineprivateinherited

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

Definition at line 183 of file InputParametersChecksUtils.h.

  {
    _customer_class->mooseWarning(std::forward<Args>(args)...);
  }

◆ forwardName()

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

inlineprivatevirtualinherited

Get the name of the class using this utility.

Definition at line 190 of file InputParametersChecksUtils.h.

190{ return _customer_class->name(); }

◆ forwardParamError()

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

inlineprivateinherited

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

Definition at line 171 of file InputParametersChecksUtils.h.

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

◆ forwardParameters()

const InputParameters & InputParametersChecksUtils< ActionComponent >::forwardParameters ( ) const

inlineprivateinherited

Forwards obtaining parameters to the class using this utility.

Definition at line 158 of file InputParametersChecksUtils.h.

158{ return _customer_class->parameters(); }

◆ forwardType()

const std::string & InputParametersChecksUtils< ActionComponent >::forwardType ( ) const

inlineprivateinherited

Get the type of the class using this utility.

Definition at line 188 of file InputParametersChecksUtils.h.

188{ return _customer_class->type(); }

◆ getAllTasks()

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

inlineinherited

Definition at line 112 of file Action.h.

112{ return _all_tasks; }

Referenced by AddKernelAction::act().

◆ getBase()

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

inlineinherited

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

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

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

◆ getCheckedPointerParam()

template<typename T >

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

inherited

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

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

Definition at line 450 of file MooseBase.h.

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

◆ getConnectedComponents()

const std::set< ActionComponent * > & ActionComponent::getConnectedComponents ( ) const

inlineinherited

Get all components connected to the component group of this component (including itself)

Definition at line 71 of file ActionComponent.h.

  {
    return *_connected_components;
  }

◆ getCurrentTopLevelMeshGeneratorName()

MeshGeneratorName ActionComponent::getCurrentTopLevelMeshGeneratorName ( ) const

inlineinherited

Return the name of the final mesh generator that contains this component This may not be one of the mesh generators of the component.

If the component's mesh is combined with or stitched to another component, the combiner/stitcher would be the final mesh generator

Definition at line 42 of file ActionComponent.h.

42{ return _top_mg_name; }

ActionComponent::_top_mg_name

MeshGeneratorName _top_mg_name

Name of the top-most mesh generator in the hierarchy of MGs on top of the ones generating this compon...

Definition ActionComponent.h:123

Referenced by ComponentJunction::addMeshGenerators().

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

{
  // 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.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  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;
}

Referenced by DataFileInterface::getDataFileNameByName().

◆ getFactory()

Factory & ActionComponent::getFactory ( ) const

inlineprotectedinherited

Get the factory to build (often physics-related but not always) objects (for example a Positions)

Definition at line 115 of file ActionComponent.h.

115{ return _factory; }

Referenced by addMaterials().

◆ getHitNode() [1/2]

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

inlineinherited

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

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

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

staticprivateinherited

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

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

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

◆ getMeshProperty() [1/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 64 of file MeshMetaDataInterface.h.

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

◆ getMeshProperty() [2/2]

template<typename T >

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

protectedinherited

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

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

Definition at line 142 of file MeshMetaDataInterface.h.

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

◆ getMeshPropertyInternal()

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

privateinherited

Helper for getting a mesh property.

Definition at line 54 of file MeshMetaDataInterface.C.

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

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

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

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

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

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

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

◆ getProblem()

FEProblemBase & ActionComponent::getProblem ( )

inlineprotectedinherited

Get problem from action warehouse.

Definition at line 108 of file ActionComponent.h.

  {
    mooseAssert(_awh.problemBase().get(), "There should be a problem");
    return *_awh.problemBase().get();
  }

Referenced by addMaterials().

◆ getPropertyValue()

const MooseFunctorName & ComponentMaterialPropertyInterface::getPropertyValue	(	const std::string &	property_name,
		const std::string &	requestor_name
	)		const

Return the name of the functor for that property.

Definition at line 107 of file ComponentMaterialPropertyInterface.C.

{
  for (const auto i : index_range(_property_names))
    if (_property_names[i] == property_name)
      return _property_functors[i];
  mooseError("Property '",
             property_name,
             "' was requested on Component '",
             name(),
             "' by Physics '",
             requestor_name,
             "'");
}

◆ 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 420 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 + "'");
}

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

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

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasMeshProperty() [1/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string & data_name ) const

inlineprotectedinherited

Returns: Whether or not a mesh meta-data exists with the default prefix.

Definition at line 82 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [2/4]

template<typename T >

bool MeshMetaDataInterface::hasMeshProperty ( const std::string & data_name ) const

inlineprotectedinherited

Returns: Whether or not a mesh meta-data exists with the default prefix and the given type.

Definition at line 90 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [3/4]

bool MeshMetaDataInterface::hasMeshProperty	(	const std::string &	data_name,
		const std::string &	prefix
	)		const

protectedinherited

Returns: Whether or not a mesh meta-data exists.

Definition at line 33 of file MeshMetaDataInterface.C.

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

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

◆ hasMeshProperty() [4/4]

template<typename T >

bool MeshMetaDataInterface::hasMeshProperty	(	const std::string &	data_name,
		const std::string &	prefix
	)		const

protectedinherited

Returns: Whether or not a mesh meta-data exists with the given type.

Definition at line 166 of file MeshMetaDataInterface.h.

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

◆ hasProperty()

bool ComponentMaterialPropertyInterface::hasProperty ( const std::string & property_name ) const

Whether the component has a property with that name.

Definition at line 99 of file ComponentMaterialPropertyInterface.C.

{
  return std::find(_property_names.begin(), _property_names.end(), property_name) !=
         _property_names.end();
}

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

  {
    return _pars.isParamSetByUser(name);
  }

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

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

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

Definition InputParameters.C:386

◆ meshGeneratorNames()

const std::vector< MeshGeneratorName > & ActionComponent::meshGeneratorNames ( ) const

inlineinherited

Get the name(s) of the mesh generator(s) created by this component that generates the mesh for it.

this could be a mesh generator in the [Mesh] block
or a mesh generator created by the component

Definition at line 38 of file ActionComponent.h.

38{ return _mg_names; }

ActionComponent::_mg_names

std::vector< MeshGeneratorName > _mg_names

Name(s) of the final mesh generator(s) creating the mesh for the component.

Definition ActionComponent.h:121

Referenced by ComponentJunction::addMeshGenerators().

◆ meshPropertyName() [1/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string & data_name ) const

inlineprotectedinherited

Returns: The default mesh property name for mesh property data

Definition at line 103 of file MeshMetaDataInterface.h.

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

◆ meshPropertyName() [2/2]

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

staticprotectedinherited

Returns: The full name for mesh property data.

Definition at line 41 of file MeshMetaDataInterface.C.

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

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

◆ meshPropertyPrefix()

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

privatevirtualinherited

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

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

Reimplemented in MeshGenerator.

Definition at line 47 of file MeshMetaDataInterface.C.

{
  mooseError("This object does not support obtaining a mesh property without a prefix.\n\nThis "
             "capability is upcoming.");
}

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

◆ messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool hit_prefix = true ) const

inlineinherited

Returns: A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

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

◆ messagePrefix() [2/2]

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

staticprivateinherited

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

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

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 317 of file MooseBase.h.

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

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

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

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

Definition at line 327 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, false, 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 277 of file MooseBase.h.

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

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

◆ mooseErrorInternal()

template<typename... Args>

void MeshMetaDataInterface::mooseErrorInternal ( Args &&... args ) const

inlineprivateinherited

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

Definition at line 132 of file MeshMetaDataInterface.h.

  {
    if (_meta_data_object)
      _meta_data_object->mooseError(std::forward<Args>(args)...);
    mooseError(std::forward<Args>(args)...);
  }

Referenced by MeshMetaDataInterface::getMeshProperty().

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

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

◆ outerSurfaceArea()

virtual Real ActionComponent::outerSurfaceArea ( ) const

inlinevirtualinherited

Return the component outer boundary area.

Reimplemented in CylinderComponent.

Definition at line 62 of file ActionComponent.h.

62{ mooseError("Outer surface area is not implemented"); }

◆ outerSurfaceBoundaries()

virtual const std::vector< BoundaryName > & ActionComponent::outerSurfaceBoundaries ( ) const

inlinevirtualinherited

Return the outer surface boundaries.

Definition at line 53 of file ActionComponent.h.

  {
    mooseError("Not implemented");
  };

◆ paramError()

template<typename... Args>

void MooseBase::paramError	(	const std::string &	param,
		Args...	args
	)		const

inherited

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

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

Definition at line 457 of file MooseBase.h.

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

◆ parameterConsistent()

bool InputParametersChecksUtils< ActionComponent >::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 126 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 131 of file MooseBase.h.

131{ 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 471 of file MooseBase.h.

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

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

◆ paramWarning() [1/2]

template<typename... Args>

void MooseBase::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

template<typename... Args>

void SolutionInvalidInterface::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

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

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

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

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

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

◆ registerInvalidSolutionInternal()

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

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

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

◆ setCurrentTopLevelMeshGeneratorName()

void ActionComponent::setCurrentTopLevelMeshGeneratorName ( const MeshGeneratorName & mg_name )

inlineinherited

Set the name of the final mesh generator that contains this component.

Definition at line 44 of file ActionComponent.h.

  {
    _top_mg_name = mg_name;
  }

Referenced by ComponentMeshTransformHelper::addMeshGenerators().

◆ setupComponent()

virtual void ActionComponent::setupComponent ( )

inlineprotectedvirtualinherited

Reimplemented in CylinderComponent, and MeshGeneratorComponent.

Definition at line 83 of file ActionComponent.h.

83{}

Referenced by ActionComponent::act().

◆ specificTaskName()

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

inlineinherited

Definition at line 110 of file Action.h.

110{ return _specific_task_name; }

Action::_specific_task_name

std::string _specific_task_name

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

Definition Action.h:159

◆ timedAct()

void Action::timedAct ( )

inherited

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

Definition at line 76 of file Action.C.

{
  TIME_SECTION(_act_timer);
 
  const auto parallel_verify = [libmesh_dbg_var(this)](const bool libmesh_dbg_var(before))
  {
#ifndef NDEBUG
    const std::string value = this->typeAndName() + "_" + _current_task;
    if (!comm().verify(value.size()) || !comm().verify(value))
      mooseError("Parallel inconsistency found ",
                 before ? "before" : "after",
                 " executing task ",
                 _current_task);
#endif
  };
 
  parallel_verify(true);
 
  act();
 
  parallel_verify(false);
}

Referenced by ActionWarehouse::executeActionsWithAction().

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string & section_name ) const

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

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

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

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

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

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

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

◆ uniqueActionName()

MooseObjectName Action::uniqueActionName ( ) const

inlineinherited

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

Definition at line 108 of file Action.h.

108{ return uniqueName(); }

Referenced by NEML2Action::NEML2Action().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

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

Definition at line 69 of file MooseBase.C.

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

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

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string & parameter_name ) const

inherited

Returns: The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

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

◆ validParams()

InputParameters ComponentMaterialPropertyInterface::validParams ( )

static

Definition at line 15 of file ComponentMaterialPropertyInterface.C.

{
  auto params = ActionComponent::validParams();
  params.addParam<std::vector<std::string>>(
      "property_names",
      {},
      "List of material properties that should be defined on this ActionComponent");
  params.addParam<std::vector<MooseFunctorName>>(
      "property_values",
      {},
      "Functors that provide the values of the material property on this ActionComponent");
 
  // TODO: make the Physics set these three parameters
  params.addParam<bool>("use_ad_for_properties",
                        true,
                        "Whether to use automatic differentiation for the properties defined");
  params.addParam<bool>("define_material_properties",
                        true,
                        "If true, define material properties from the values provided");
  params.addParam<bool>("define_functor_properties",
                        true,
                        "If true, define functor properties from the values provided");
 
  params.addParamNamesToGroup("property_names property_values use_ad_for_properties "
                              "define_material_properties define_functor_properties",
                              "Material and Functor Property");
  return params;
}

Referenced by ComponentJunction::validParams(), CylinderComponent::validParams(), and MeshGeneratorComponent::validParams().

◆ volume()

virtual Real ActionComponent::volume ( ) const

inlinevirtualinherited

Return the component volume.

Reimplemented in CylinderComponent.

Definition at line 59 of file ActionComponent.h.

59{ mooseError("Volume routine is not implemented"); }

◆ warnInconsistent()

void InputParametersChecksUtils< ActionComponent >::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 132 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 181 of file Action.h.

Referenced by Action::timedAct().

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

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

◆ _all_tasks

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

protectedinherited

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

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

Definition at line 166 of file Action.h.

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

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

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

◆ _awh

ActionWarehouse& Action::_awh

protectedinherited

Reference to ActionWarehouse where we store object build by actions.

Definition at line 169 of file Action.h.

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

◆ _blocks

std::vector<SubdomainName> ActionComponent::_blocks

protectedinherited

Names of the blocks the component is comprised of.

Definition at line 126 of file ActionComponent.h.

Referenced by addMaterials(), CylinderComponent::addMeshGenerators(), ComponentPhysicsInterface::addPhysics(), ActionComponent::blocks(), CylinderComponent::setupComponent(), and MeshGeneratorComponent::setupComponent().

◆ _connected_components

std::shared_ptr<std::set<ActionComponent *> > ActionComponent::_connected_components

protectedinherited

Group of components that share a common mesh after junctioning.

The shared_ptr is shared by every member of the group so connectivity updates are visible from any member.

Definition at line 139 of file ActionComponent.h.

Referenced by ActionComponent::ActionComponent(), ActionComponent::addConnectedComponent(), and ActionComponent::getConnectedComponents().

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

◆ _current_task

const std::string& Action::_current_task

protectedinherited

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

Definition at line 172 of file Action.h.

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

◆ _customer_class

const ActionComponent * const InputParametersChecksUtils< ActionComponent >::_customer_class

privateinherited

Definition at line 200 of file InputParametersChecksUtils.h.

◆ _dimension

unsigned int ActionComponent::_dimension

protectedinherited

Maximum dimension of the component.

Definition at line 118 of file ActionComponent.h.

Referenced by ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), CylinderComponent::CylinderComponent(), ActionComponent::dimension(), CylinderComponent::setupComponent(), and CylinderComponent::translation().

◆ _displaced_mesh

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

protectedinherited

Definition at line 175 of file Action.h.

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

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

◆ _mesh

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

protectedinherited

◆ _meta_data_app

MooseApp& MeshMetaDataInterface::_meta_data_app

privateinherited

Reference to the application.

Definition at line 122 of file MeshMetaDataInterface.h.

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

◆ _meta_data_object

const MooseObject* const MeshMetaDataInterface::_meta_data_object

privateinherited

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

Definition at line 125 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::mooseErrorInternal().

◆ _mg_names

std::vector<MeshGeneratorName> ActionComponent::_mg_names

protectedinherited

Name(s) of the final mesh generator(s) creating the mesh for the component.

Definition at line 121 of file ActionComponent.h.

Referenced by ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGeneratorComponent::addMeshGenerators(), and ActionComponent::meshGeneratorNames().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _outer_boundaries

std::vector<BoundaryName> ActionComponent::_outer_boundaries

protectedinherited

Names of the boundaries on the component outer surface.

Definition at line 129 of file ActionComponent.h.

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

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

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

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

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _problem

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

protectedinherited

Convenience reference to a problem this action works on.

Definition at line 178 of file Action.h.

◆ _property_functors

const std::vector<MooseFunctorName> ComponentMaterialPropertyInterface::_property_functors

protected

Functor values of the material properties.

Definition at line 42 of file ComponentMaterialPropertyInterface.h.

Referenced by addMaterials(), ComponentMaterialPropertyInterface(), and getPropertyValue().

◆ _property_names

const std::vector<std::string> ComponentMaterialPropertyInterface::_property_names

protected

Names of the material properties.

Definition at line 40 of file ComponentMaterialPropertyInterface.h.

Referenced by addMaterials(), ComponentMaterialPropertyInterface(), getPropertyValue(), and hasProperty().

◆ _registered_identifier

std::string Action::_registered_identifier

protectedinherited

Definition at line 151 of file Action.h.

Referenced by SetupMeshAction::act().

◆ _required_tasks

std::set<std::string> ActionComponent::_required_tasks

protectedinherited

Manually keeps track of the tasks required by each component as tasks cannot be inherited.

Definition at line 135 of file ActionComponent.h.

Referenced by ActionComponent::addRequiredTask(), and ActionComponent::checkRequiredTasks().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

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

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _specific_task_name

std::string Action::_specific_task_name

protectedinherited

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

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

Definition at line 159 of file Action.h.

Referenced by Action::specificTaskName().

◆ _top_mg_name

MeshGeneratorName ActionComponent::_top_mg_name

protectedinherited

Name of the top-most mesh generator in the hierarchy of MGs on top of the ones generating this component.

Definition at line 123 of file ActionComponent.h.

Referenced by ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ActionComponent::getCurrentTopLevelMeshGeneratorName(), and ActionComponent::setCurrentTopLevelMeshGeneratorName().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

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

◆ _use_ad_for_props

const bool ComponentMaterialPropertyInterface::_use_ad_for_props

protected

Whether to use automatic differentiation when defining properties.

Definition at line 44 of file ComponentMaterialPropertyInterface.h.

Referenced by addMaterials().

◆ _verbose

const bool ActionComponent::_verbose

protectedinherited

Whether the component setup should be verbose.

Definition at line 132 of file ActionComponent.h.

Referenced by ComponentJunction::addMeshGenerators(), and ComponentPhysicsInterface::addPhysics().

◆ app_param

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

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

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

◆ kokkos_object_param

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

staticinherited

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

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

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

staticinherited

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

Definition at line 61 of file MooseBase.h.

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

◆ NAME

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

staticconstexprinherited

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

Definition at line 33 of file MeshMetaDataInterface.h.

◆ name_param

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

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

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

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticconstexprinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

◆ type_param

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

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

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

◆ unique_action_name_param

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

staticinherited

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

Definition at line 41 of file Action.h.

Referenced by Action::validParams().

◆ unique_name_param

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

staticinherited

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

Definition at line 57 of file MooseBase.h.

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

◆ usingCombinedWarningSolutionWarnings

Action::usingCombinedWarningSolutionWarnings

inherited

Definition at line 55 of file Action.h.

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

include/actioncomponents/ComponentMaterialPropertyInterface.h
src/actioncomponents/ComponentMaterialPropertyInterface.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ ComponentMaterialPropertyInterface()

Member Function Documentation

◆ act()

◆ actOnAdditionalTasks()

◆ addConnectedComponent()

◆ addMaterials()

◆ addMeshGenerators()

◆ addPhysics()

◆ addPositionsObject()

◆ addRelationshipManager()

◆ addRelationshipManagers() [1/2]

◆ addRelationshipManagers() [2/2]

◆ addRequiredTask()

◆ addSolverVariables()

◆ addUserObjects()

◆ appendTask()

◆ assertParamDefined() [1/2]

◆ assertParamDefined() [2/2]

◆ associateWithParameter() [1/2]

◆ associateWithParameter() [2/2]

◆ blocks()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkBlockwiseConsistency()

◆ checkIntegrity()

◆ checkParamsBothSetOrNotSet()

◆ checkRequiredTasks()

◆ checkSecondParamNotSetIfFirstOneSet()

◆ checkSecondParamSetOnlyIfFirstOneSet()

◆ checkSecondParamSetOnlyIfFirstOneTrue()

◆ checkTwoDVectorParamInnerSameLengthAsOneDVector()

◆ checkTwoDVectorParamMultiMooseEnumSameLength()

◆ checkTwoDVectorParamsNoRespectiveOverlap()

◆ checkTwoDVectorParamsSameLength()

◆ checkVectorParamAndMultiMooseEnumLength()

◆ checkVectorParamLengthSameAsCombinedOthers()

◆ checkVectorParamNotEmpty()

◆ checkVectorParamsNoOverlap()

◆ checkVectorParamsSameLength()

◆ checkVectorParamsSameLengthIfSet()

◆ connectControllableParams()

◆ dimension()

◆ errorDependentParameter()

◆ errorInconsistentDependentParameter()

◆ errorPrefix()

◆ flagInvalidSolutionInternal()

◆ forwardBlocks()

◆ forwardGetParam()

◆ forwardIsParamSetByUser()

◆ forwardIsParamValid()

◆ forwardMooseError()

◆ forwardMooseWarning()

◆ forwardName()

◆ forwardParamError()

◆ forwardParameters()

◆ forwardType()

◆ getAllTasks()

◆ getBase()

◆ getCheckedPointerParam()

◆ getConnectedComponents()

◆ getCurrentTopLevelMeshGeneratorName()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getFactory()