MultiAppUserObjectTransfer Class Reference

Loops over a target mesh and uses either node or element centroid location (based on the target variable type) for sampling a user object (i.e. More...

#include <MultiAppUserObjectTransfer.h>

Inheritance diagram for MultiAppUserObjectTransfer:

Public Types
enum	DIRECTION { TO_MULTIAPP, FROM_MULTIAPP, BETWEEN_MULTIAPP }
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name. More...

Public Member Functions
	MultiAppUserObjectTransfer (const InputParameters &parameters)
virtual void	execute () override
	Execute the transfer. More...
virtual void	initialSetup () override
	Method called at the beginning of the simulation for checking integrity or doing one-time setup. More...
virtual void	postExecute ()
	Add some extra work if necessary after execute(). More...
void	variableIntegrityCheck (const AuxVariableName &var_name, bool is_from_multiapp) const
	Utility to verify that the variable in the destination system exists. More...
const std::shared_ptr< MultiApp >	getMultiApp () const
	Use this getter to obtain the MultiApp for transfers with a single direction. More...
const std::shared_ptr< MultiApp >	getFromMultiApp () const
	Get the MultiApp to transfer data from. More...
const std::shared_ptr< MultiApp >	getToMultiApp () const
	Get the MultiApp to transfer data to. More...
std::string	getFromName () const
	Get the name of thing being transferred from. More...
std::string	getToName () const
	Get the name of thing being transferred to. More...
bool	hasFromMultiApp () const
	Whether the transfer owns a non-null from_multi_app. More...
bool	hasToMultiApp () const
	Whether the transfer owns a non-null to_multi_app. More...
virtual void	getAppInfo ()
	This method will fill information into the convenience member variables (_to_problems, _from_meshes, etc.) More...
const MultiMooseEnum &	directions ()
	The directions this Transfer should be executed on. More...
void	setCurrentDirection (const int direction)
	Set this Transfer to be executed in a given direction. More...
virtual bool	enabled () const
	Return the enabled status of the object. More...
std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group. More...
std::shared_ptr< const MooseObject >	getSharedPtr () const
MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with. More...
const std::string &	type () const
	Get the type of this class. More...
virtual const std::string &	name () const
	Get the name of the class. More...
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...
std::string	errorPrefix (const std::string &error_type) const
void	callMooseError (std::string msg, const bool with_prefix) const
	Calls moose error with the message msg. More...
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
	The unique parameter name of a valid parameter of this object for accessing parameter controls. More...
const InputParameters &	parameters () const
	Get the parameters of the object. More...
MooseObjectName	uniqueName () const
	The unique name for accessing input parameters of this object in the InputParameterWarehouse. More...
template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object. More...
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...
bool	isParamSetByUser (const std::string &nm) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...
template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...
template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type. More...
template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError(). More...
template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
	Emits a documented error with object name and type. More...
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
std::string	getDataFileName (const std::string &param) const
	Deprecated method. More...
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...
virtual void	timestepSetup ()
	Gets called at the beginning of the timestep before this object is asked to do its job. More...
virtual void	jacobianSetup ()
	Gets called just before the Jacobian is computed and before this object is asked to do its job. More...
virtual void	residualSetup ()
	Gets called just before the residual is computed and before this object is asked to do its job. More...
virtual void	subdomainSetup ()
	Gets called when the subdomain changes (i.e. More...
virtual void	customSetup (const ExecFlagType &)
	Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain. More...
const ExecFlagEnum &	getExecuteOnEnum () const
	Return the execute on MultiMooseEnum for this object. More...
PerfGraph &	perfGraph ()
	Get the PerfGraph. More...
MooseEnum	direction ()
MooseEnum	currentDirection ()

Static Public Member Functions
static InputParameters	validParams ()
static void	addSkipCoordCollapsingParam (InputParameters &params)
	Add the option to skip coordinate collapsing in coordinate transformation operations. More...
static libMesh::System *	find_sys (libMesh::EquationSystems &es, const std::string &var_name)
	Small helper function for finding the system containing the variable. More...
static std::string	possibleDirections ()
	Used to construct InputParameters. More...

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

Static Public Attributes
static const libMesh::Number	OutOfMeshValue = -999999

Protected Member Functions
bool	blockRestricted () const
bool	boundaryRestricted () const
bool	hasBlocks (const Elem *elem) const
	Check that element 'elem' is part of the domain this transfer is restricted to. More...
bool	hasBlocks (const MooseMesh *mesh, const Node *node) const
	Check that Node 'node' belongs to block this transfer is restricted to. More...
bool	isBoundaryNode (const MooseMesh *mesh, const Node *node) const
	Check that the node belongs to boundary this transfer is restricted to. More...
bool	isBoundaryElem (const MooseMesh *mesh, const Elem *elem) const
	Check that the element belongs to boundary this transfer is restricted to. More...
unsigned int	findSubAppToTransferFrom (const Point &p)
	Gets the UserObject to transfer from when transferring from_multiapp. More...
virtual std::vector< VariableName >	getFromVarNames () const override
	Virtual function defining variables to be transferred. More...
virtual std::vector< AuxVariableName >	getToVarNames () const override
	Virtual function defining variables to transfer to. More...
bool	performAdjustment (const PostprocessorValue &from, const PostprocessorValue &to) const
libMesh::EquationSystems &	getEquationSystem (FEProblemBase &problem, bool use_displaced) const
	Returns the Problem's equation system, displaced or not Be careful! If you transfer TO a displaced system you will likely need a synchronization So most transfers reach the non-displaced system directly. More...
std::vector< unsigned int >	getFromsPerProc ()
	Return the number of "from" domains that each processor owns. More...
libMesh::NumericVector< Real > &	getTransferVector (unsigned int i_local, std::string var_name)
	If we are transferring to a multiapp, return the appropriate solution vector. More...
unsigned int	getGlobalSourceAppIndex (unsigned int i_from) const
	Return the global app index from the local index in the "from-multiapp" transfer direction. More...
unsigned int	getGlobalTargetAppIndex (unsigned int i_to) const
	Return the global app index from the local index in the "to-multiapp" transfer direction. More...
unsigned int	getLocalSourceAppIndex (unsigned int i_from) const
	Return the local app index from the global index in the "from-multiapp" transfer direction We use the fact that global app indexes are consecutive on a given rank. More...
virtual void	checkSiblingsTransferSupported () const
	Whether the transfer supports siblings transfer. More...
Point	getPointInTargetAppFrame (const Point &p, unsigned int local_i_to, const std::string &phase) const
	Get the target app point from a point in the reference frame. More...
void	checkMultiAppExecuteOn ()
	Helper method for checking the 'check_multiapp_execute_on' flag. More...
void	checkVariable (const FEProblemBase &fe_problem, const VariableName &var_name, const std::string &param_name="") const
	Helper for checking a problem for a variable. More...
void	extendBoundingBoxes (const Real factor, std::vector< libMesh::BoundingBox > &bboxes) const
	Extends bounding boxes to avoid missing points. More...
template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...
template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...
std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing. More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing. More...
std::string	timedSectionName (const std::string &section_name) const
std::vector< libMesh::BoundingBox >	getFromBoundingBoxes ()
	Return the bounding boxes of all the "from" domains, including all the domains not local to this processor. More...
std::vector< libMesh::BoundingBox >	getFromBoundingBoxes (BoundaryID boundary_id)

Static Protected Member Functions
static void	addBBoxFactorParam (InputParameters &params)
	Add the bounding box factor parameter to the supplied input parameters. More...
static void	transformBoundingBox (libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)
	Transform a bounding box according to the transformations in the provided coordinate transformation object. More...

Protected Attributes
std::string	_user_object_name
const bool	_all_parent_nodes_contained_in_sub_app
	Boolean variable to generate error if every parent app node cannot be mapped to a subApp during from_multiapp transfer. More...
const bool	_skip_bbox_check
	whether to check the bounding box check or not More...
const bool &	_nearest_sub_app
	Whether to utilize the nearest sub-app to transfer from. More...
const std::vector< VariableName >	_from_var_names
	Name of variables transferring from. More...
const std::vector< AuxVariableName >	_to_var_names
	Name of variables transferring to. More...
VariableName	_from_var_name
	This values are used if a derived class only supports one variable. More...
AuxVariableName	_to_var_name
bool	_preserve_transfer
	If this transfer is going to conserve the physics. More...
std::vector< PostprocessorName >	_from_postprocessors_to_be_preserved
	Postprocessor evaluates an adjuster for the source physics. More...
std::vector< PostprocessorName >	_to_postprocessors_to_be_preserved
	Postprocessor evaluates an adjuster for the target physics. More...
std::shared_ptr< MultiApp >	_multi_app
	Deprecated class attribute for compatibility with the apps. More...
std::vector< FEProblemBase * >	_to_problems
std::vector< FEProblemBase * >	_from_problems
std::vector< libMesh::EquationSystems * >	_to_es
std::vector< libMesh::EquationSystems * >	_from_es
std::vector< MooseMesh * >	_to_meshes
std::vector< MooseMesh * >	_from_meshes
std::vector< Point >	_to_positions
std::vector< Point >	_from_positions
std::vector< std::unique_ptr< MultiAppCoordTransform > >	_to_transforms
std::vector< std::unique_ptr< MultiAppCoordTransform > >	_from_transforms
const bool	_skip_coordinate_collapsing
	Whether to skip coordinate collapsing (transformations of coordinates between applications using different frames of reference) More...
bool	_displaced_source_mesh
	True if displaced mesh is used for the source mesh, otherwise false. More...
bool	_displaced_target_mesh
	True if displaced mesh is used for the target mesh, otherwise false. More...
Real	_bbox_factor
	Extend (or contract) bounding box by a factor in all directions Greater than one values of this member may be necessary because the nearest bounding box does not necessarily give you the closest node/element. More...
std::vector< unsigned int >	_to_local2global_map
	Given local app index, returns global app index. More...
std::vector< unsigned int >	_from_local2global_map
	Given local app index, returns global app index. More...
SubProblem &	_subproblem
FEProblemBase &	_fe_problem
SystemBase &	_sys
THREAD_ID	_tid
MultiMooseEnum	_directions
	The directions this Transfer is to be executed on. More...
const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...
MooseApp &	_app
	The MOOSE application this is associated with. More...
const std::string	_type
	The type of this class. More...
const std::string	_name
	The name of this class. More...
const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
Factory &	_factory
	The Factory associated with the MooseApp. More...
ActionFactory &	_action_factory
	Builds Actions. More...
const Parallel::Communicator &	_communicator
const ExecFlagEnum &	_execute_enum
	Execute settings for this object. More...
const ExecFlagType &	_current_execute_flag
	Reference to FEProblemBase. More...
MooseApp &	_restartable_app
	Reference to the application. More...
const std::string	_restartable_system_name
	The system name this object is in. More...
const THREAD_ID	_restartable_tid
	The thread ID for this object. More...
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...
const std::string	_prefix
	A prefix to use for all sections. More...
MooseEnum	_direction
MooseEnum	_current_direction

Private Member Functions
bool	usesMooseAppCoordTransform () const override
	Whether this transfer handles non-translation-based transformations, e.g. More...

Private Attributes
std::set< SubdomainID >	_blk_ids
	Set of block ids this transfer is restricted to. More...
std::set< BoundaryID >	_bnd_ids
	Set of the boundary ids. More...

Detailed Description

Loops over a target mesh and uses either node or element centroid location (based on the target variable type) for sampling a user object (i.e.

the object must implement spatialValue API). This value is then stored into the target variable (either nodal or elemental). Note: Higher order variables are not supported.

This transfer can be block and boundary restricted. The BlockRestrictable and BoundaryRestrictable classes cannot be used, because they would check the block, boundary and target variable during object construction. At that time, the underlying sub-app is not created yet, so this check would fail. That is also the reason why the block and boundary restriction are pulled in during execute and not in the constructor. Also note, that in a sub-app setup there might be multiple instances of the sub-app, so this check needs to be done on per-sub-app basis.

Definition at line 28 of file MultiAppUserObjectTransfer.h.

Member Typedef Documentation

DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

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

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

DIRECTION

enum Transfer::DIRECTION

inherited

Enumerator
TO_MULTIAPP
FROM_MULTIAPP
BETWEEN_MULTIAPP

Definition at line 68 of file Transfer.h.

  {
    TO_MULTIAPP,
    FROM_MULTIAPP,
    BETWEEN_MULTIAPP
  };

Constructor & Destructor Documentation

MultiAppUserObjectTransfer()

MultiAppUserObjectTransfer::MultiAppUserObjectTransfer

(

const InputParameters &

parameters

)

Definition at line 80 of file MultiAppUserObjectTransfer.C.

  : MultiAppConservativeTransfer(parameters),
    _user_object_name(getParam<UserObjectName>("user_object")),
    _all_parent_nodes_contained_in_sub_app(
        isParamValid("all_master_nodes_contained_in_sub_app")
            ? getParam<bool>("all_master_nodes_contained_in_sub_app")
            : getParam<bool>("all_parent_nodes_contained_in_sub_app")),
    _skip_bbox_check(getParam<bool>("skip_bounding_box_check")),
    _nearest_sub_app(getParam<bool>("nearest_sub_app"))
{
  mooseDeprecated("MultiAppUserObjectTransfer is deprecated. Use "
                  "MultiAppGeneralFieldUserObjectTransfer instead and adapt the parameters");

  // This transfer does not work with DistributedMesh
  _fe_problem.mesh().errorIfDistributedMesh("MultiAppUserObjectTransfer");

  if (_to_var_names.size() != 1)
    paramError("variable", " Support single to-variable only ");

  if (_from_var_names.size() > 0)
    paramError("source_variable",
               " You should not provide any source variables since the transfer takes values from "
               "user objects ");

  if (isParamValid("block") && isParamValid("boundary"))
    mooseError(name(), ": Transfer can be either block- or boundary-restricted. Not both.");

  if (isParamValid("to_multi_app") && isParamValid("from_multi_app") &&
      getToMultiApp() != getFromMultiApp())
    paramError("to_multi_app",
               "Sibling multiapp transfer has not been implemented for this transfer.");
}

Member Function Documentation

addBBoxFactorParam()

void MultiAppTransfer::addBBoxFactorParam ( InputParameters &  params )

staticprotectedinherited

Add the bounding box factor parameter to the supplied input parameters.

Definition at line 54 of file MultiAppTransfer.C.

Referenced by MultiAppShapeEvaluationTransfer::validParams(), MultiAppProjectionTransfer::validParams(), and MultiAppNearestNodeTransfer::validParams().

{
  params.addRangeCheckedParam<Real>(
      "bbox_factor",
      1 + TOLERANCE,
      "bbox_factor>0",
      "Multiply bounding box width (in all directions) by the prescribed factor. Values less than "
      "1 will shrink the bounding box; values greater than 1 will enlarge the bounding box. It is "
      "generally not advised to ever shrink the bounding box. On the other hand it may be helpful "
      "to enlarge the bounding box. Larger bounding boxes will lead to more accurate determination "
      "of the closest node/element with the tradeoff of more communication.");
}

addSkipCoordCollapsingParam()

void MultiAppTransfer::addSkipCoordCollapsingParam ( InputParameters &  params )

staticinherited

Add the option to skip coordinate collapsing in coordinate transformation operations.

Definition at line 68 of file MultiAppTransfer.C.

Referenced by MultiAppTransfer::validParams().

{
  params.addParam<bool>(
      "skip_coordinate_collapsing",
      true,
      "Whether to skip coordinate collapsing (translation and rotation are still performed, only "
      "XYZ, RZ etc collapsing is skipped) when performing mapping and inverse "
      "mapping coordinate transformation operations. This parameter should only "
      "be set by users who really know what they're doing.");
  params.addParamNamesToGroup("skip_coordinate_collapsing", "Advanced");
}

blockRestricted()

bool MultiAppUserObjectTransfer::blockRestricted ( ) const

protected

Returns

true if this transfer is restricted to a block, otherwise false

Definition at line 556 of file MultiAppUserObjectTransfer.C.

Referenced by execute().

{
  return !_blk_ids.empty();
}

boundaryRestricted()

bool MultiAppUserObjectTransfer::boundaryRestricted ( ) const

protected

Returns

true if this transfer is restricted to a boundary, otherwise false

Definition at line 562 of file MultiAppUserObjectTransfer.C.

Referenced by execute().

{
  return !_bnd_ids.empty();
}

callMooseError()

void MooseBase::callMooseError ( std::string  msg, const bool  with_prefix  ) const

inherited

Calls moose error with the message msg.

Will prefix the message with the subapp name if one exists.

If with_prefix, then add the prefix from errorPrefix() to the error.

Definition at line 33 of file MooseBase.C.

Referenced by InputParameters::callMooseErrorHelper(), MooseBaseErrorInterface::mooseDocumentedError(), MooseBaseErrorInterface::mooseError(), MooseBaseErrorInterface::mooseErrorNonPrefixed(), and MooseBaseParameterInterface::paramError().

{
  _app.getOutputWarehouse().mooseConsole();
  const std::string prefix = _app.isUltimateMaster() ? "" : _app.name();
  if (with_prefix)
    msg = errorPrefix("error") + msg;
  moose::internal::mooseErrorRaw(msg, prefix);
}

checkMultiAppExecuteOn()

void MultiAppTransfer::checkMultiAppExecuteOn ( )

protectedinherited

Helper method for checking the 'check_multiapp_execute_on' flag.

This method was added to allow the check to be delayed by child classes, see StochasticToolsTransfer for an example.

Definition at line 158 of file MultiAppTransfer.C.

Referenced by MultiAppTransfer::MultiAppTransfer().

{
  if (_from_multi_app && !_to_multi_app)
    if (getExecuteOnEnum() != _from_multi_app->getExecuteOnEnum())
      mooseDoOnce(
          mooseWarning("MultiAppTransfer execute_on flags do not match associated from_multi_app "
                       "execute_on flags"));

  if (_to_multi_app && !_from_multi_app)
    if (getExecuteOnEnum() != _to_multi_app->getExecuteOnEnum())
      mooseDoOnce(
          mooseWarning("MultiAppTransfer execute_on flags do not match associated to_multi_app "
                       "execute_on flags"));

  // In the case of siblings transfer, the check will be looser
  if (_from_multi_app && _to_multi_app)
    if (getExecuteOnEnum() != _from_multi_app->getExecuteOnEnum() &&
        getExecuteOnEnum() != _to_multi_app->getExecuteOnEnum())
      mooseDoOnce(
          mooseWarning("MultiAppTransfer execute_on flags do not match associated to_multi_app "
                       "and from_multi_app execute_on flags"));
}

checkSiblingsTransferSupported()

virtual void MultiAppTransfer::checkSiblingsTransferSupported ( ) const

inlineprotectedvirtualinherited

Whether the transfer supports siblings transfer.

Reimplemented in MultiAppGeneralFieldTransfer, MultiAppCopyTransfer, MultiAppReporterTransfer, MultiAppPostprocessorTransfer, MultiAppPostprocessorToAuxScalarTransfer, and MultiAppScalarToAuxScalarTransfer.

Definition at line 210 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::initialSetup().

  {
    mooseError("Siblings transfer not supported. You cannot transfer both from a multiapp to "
               "another multiapp");
  }

checkVariable()

void MultiAppTransfer::checkVariable ( const FEProblemBase &  fe_problem, const VariableName &  var_name, const std::string &  param_name = ""  ) const

protectedinherited

Helper for checking a problem for a variable.

Parameters

fe_problem	The problem that should contain the variable
var_name	The name of the variable that should exist within the problem
param_name	(optional) The input file parameter name for throwing paramError, if not provided a mooseError is thrown.

Definition at line 598 of file MultiAppTransfer.C.

Referenced by MultiAppDofCopyTransfer::transfer().

{
  if (!fe_problem.hasVariable(var_name))
  {
    if (param_name.empty())
      mooseError("The variable '", var_name, "' does not exist.");
    else
      paramError(param_name, "The variable '", var_name, "' does not exist.");
  }
}

connectControllableParams()

void MooseBaseParameterInterface::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 33 of file MooseBaseParameterInterface.C.

{
  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  _moose_base.getMooseApp().getInputParameterWarehouse().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, _moose_base.name(), parameter);
      _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

currentDirection()

MooseEnum Transfer::currentDirection ( )

inlineinherited

Definition at line 85 of file Transfer.h.

{ return _current_direction; }

customSetup()

virtual void SetupInterface::customSetup ( const ExecFlagType &  )

inlinevirtualinherited

Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.

Reimplemented in Function.

Definition at line 61 of file SetupInterface.h.

{}

declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 276 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 351 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);

  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);

  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 269 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
args	Arguments to forward to the constructor of the data

Definition at line 323 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 333 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);

  _restartable_name = old_name;

  return value;
}

direction()

MooseEnum Transfer::direction ( )

inlineinherited

The current direction that this Transfer is going in. direction() is to be deprecated for currentDirection()

Definition at line 84 of file Transfer.h.

Referenced by Transfer::setCurrentDirection().

{ return _direction; }

directions()

const MultiMooseEnum& Transfer::directions ( )

inlineinherited

The directions this Transfer should be executed on.

Definition at line 79 of file Transfer.h.

{ return _directions; }

enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 40 of file MooseObject.h.

Referenced by EigenKernel::enabled().

{ return _enabled; }

errorPrefix()

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

inherited

Returns

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

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

{
  std::stringstream oss;
  if (const auto node = _params.getHitNode())
    if (!node->isRoot())
      oss << node->fileLocation() << ":\n";
  oss << "The following " << error_type << " occurred in the ";
  if (const auto base_ptr = _params.getBase())
    oss << *base_ptr;
  else
    oss << "object";
  oss << " '" << name() << "' of type " << type() << ".\n\n";
  return oss.str();
}

execute()

void MultiAppUserObjectTransfer::execute ( )

overridevirtual

Execute the transfer.

Implements Transfer.

Definition at line 114 of file MultiAppUserObjectTransfer.C.

{
  TIME_SECTION(
      "MultiAppUserObjectTransfer::execute()", 5, "Performing transfer with a user object");

  getAppInfo();

  switch (_current_direction)
  {
    case TO_MULTIAPP:
    {
      for (unsigned int i = 0; i < getToMultiApp()->numGlobalApps(); i++)
      {
        if (getToMultiApp()->hasLocalApp(i))
        {
          Moose::ScopedCommSwapper swapper(getToMultiApp()->comm());

          // Loop over the parent app nodes and set the value of the variable
          System * to_sys = find_sys(getToMultiApp()->appProblemBase(i).es(), _to_var_name);

          unsigned int sys_num = to_sys->number();
          unsigned int var_num = to_sys->variable_number(_to_var_name);

          NumericVector<Real> & solution = getToMultiApp()->appTransferVector(i, _to_var_name);

          MooseMesh * mesh = NULL;

          if (_displaced_target_mesh && getToMultiApp()->appProblemBase(i).getDisplacedProblem())
            mesh = &getToMultiApp()->appProblemBase(i).getDisplacedProblem()->mesh();
          else
            mesh = &getToMultiApp()->appProblemBase(i).mesh();

          _blk_ids.clear();
          _bnd_ids.clear();
          if (isParamValid("block"))
          {
            const std::vector<SubdomainName> & blocks =
                getParam<std::vector<SubdomainName>>("block");
            for (const auto & b : blocks)
              if (!MooseMeshUtils::hasSubdomainName(*mesh, b))
                paramError("block", "The block '", b, "' was not found in the mesh");

            std::vector<SubdomainID> ids = mesh->getSubdomainIDs(blocks);
            _blk_ids.insert(ids.begin(), ids.end());
          }
          else if (isParamValid("boundary"))
          {
            const std::vector<BoundaryName> & boundary_names =
                getParam<std::vector<BoundaryName>>("boundary");
            for (const auto & b : boundary_names)
              if (!MooseMeshUtils::hasBoundaryName(*mesh, b))
                paramError("boundary", "The boundary '", b, "' was not found in the mesh");

            std::vector<BoundaryID> ids = mesh->getBoundaryIDs(boundary_names, true);
            _bnd_ids.insert(ids.begin(), ids.end());
          }

          auto & fe_type = to_sys->variable_type(var_num);
          bool is_constant = fe_type.order == CONSTANT;
          bool is_nodal = fe_type.family == LAGRANGE;

          if (fe_type.order > FIRST && !is_nodal)
            mooseError("We don't currently support second order or higher elemental variable ");

          const UserObject & user_object =
              getToMultiApp()->problemBase().getUserObjectBase(_user_object_name);
          mooseAssert(_from_transforms.size() == 1, "This should have size 1");
          const auto & from_transform = *_from_transforms[0];
          const auto & to_transform = *_to_transforms[i];

          if (is_nodal)
          {
            for (auto & node : mesh->getMesh().local_node_ptr_range())
            {
              if (blockRestricted() && !hasBlocks(mesh, node))
                continue;

              if (boundaryRestricted() && !isBoundaryNode(mesh, node))
                continue;

              if (node->n_dofs(sys_num, var_num) > 0) // If this variable has dofs at this node
              {
                // The zero only works for LAGRANGE!
                dof_id_type dof = node->dof_number(sys_num, var_num, 0);

                swapper.forceSwap();
                Real from_value =
                    user_object.spatialValue(from_transform.mapBack(to_transform(*node)));
                swapper.forceSwap();

                solution.set(dof, from_value);
              }
            }
          }
          else // Elemental
          {
            std::vector<Point> points;
            for (auto & elem : as_range(mesh->getMesh().local_elements_begin(),
                                        mesh->getMesh().local_elements_end()))
            {
              if (blockRestricted() && !hasBlocks(elem))
                continue;

              if (boundaryRestricted() && !isBoundaryElem(mesh, elem))
                continue;

              // Skip this element if the variable has no dofs at it.
              if (elem->n_dofs(sys_num, var_num) < 1)
                continue;

              points.clear();
              // grap sample points
              // for constant shape function, we take the element centroid
              if (is_constant)
                points.push_back(elem->vertex_average());
              // for higher order method, we take all nodes of element
              // this works for the first order L2 Lagrange.
              else
                for (auto & node : elem->node_ref_range())
                  points.push_back(node);

              auto n_points = points.size();
              unsigned int n_comp = elem->n_comp(sys_num, var_num);
              // We assume each point corresponds to one component of elemental variable
              if (n_points != n_comp)
                mooseError(" Number of points ",
                           n_points,
                           " does not equal to number of variable components ",
                           n_comp);

              unsigned int offset = 0;
              for (auto & point : points) // If this variable has dofs at this elem
              {
                dof_id_type dof = elem->dof_number(sys_num, var_num, offset++);

                swapper.forceSwap();
                Real from_value =
                    user_object.spatialValue(from_transform.mapBack(to_transform(point)));
                swapper.forceSwap();

                solution.set(dof, from_value);
              }
            }
          }

          solution.close();
          to_sys->update();
        }
      }

      break;
    }
    case FROM_MULTIAPP:
    {
      FEProblemBase & to_problem = getFromMultiApp()->problemBase();
      mooseAssert(_to_transforms.size() == 1, "This should only be size one");
      const auto & to_transform = *_to_transforms[0];
      MooseVariableFEBase & to_var = to_problem.getVariable(
          0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
      SystemBase & to_system_base = to_var.sys();

      System & to_sys = to_system_base.system();

      unsigned int to_sys_num = to_sys.number();

      // Only works with a serialized mesh to transfer to!
      mooseAssert(to_sys.get_mesh().is_serial(),
                  "MultiAppUserObjectTransfer only works with ReplicatedMesh!");

      unsigned int to_var_num = to_sys.variable_number(to_var.name());

      // EquationSystems & to_es = to_sys.get_equation_systems();

      // Create a serialized version of the solution vector
      NumericVector<Number> * to_solution = to_sys.solution.get();

      MooseMesh * to_mesh = NULL;

      if (_displaced_target_mesh && to_problem.getDisplacedProblem())
        to_mesh = &to_problem.getDisplacedProblem()->mesh();
      else
        to_mesh = &to_problem.mesh();

      _blk_ids.clear();
      _bnd_ids.clear();
      if (isParamValid("block"))
      {
        const std::vector<SubdomainName> & blocks = getParam<std::vector<SubdomainName>>("block");
        for (const auto & b : blocks)
          if (!MooseMeshUtils::hasSubdomainName(*to_mesh, b))
            paramError("block", "The block '", b, "' was not found in the mesh");

        std::vector<SubdomainID> ids = to_mesh->getSubdomainIDs(blocks);
        _blk_ids.insert(ids.begin(), ids.end());
      }
      else if (isParamValid("boundary"))
      {
        const std::vector<BoundaryName> & boundary_names =
            getParam<std::vector<BoundaryName>>("boundary");
        for (const auto & b : boundary_names)
          if (!MooseMeshUtils::hasBoundaryName(*to_mesh, b))
            paramError("boundary", "The boundary '", b, "' was not found in the mesh");

        std::vector<BoundaryID> ids = to_mesh->getBoundaryIDs(boundary_names, true);
        _bnd_ids.insert(ids.begin(), ids.end());
      }

      auto & fe_type = to_sys.variable_type(to_var_num);
      bool is_constant = fe_type.order == CONSTANT;
      bool is_nodal = fe_type.family == LAGRANGE;

      if (fe_type.order > FIRST && !is_nodal)
        mooseError("We don't currently support second order or higher elemental variable ");

      if (_all_parent_nodes_contained_in_sub_app)
      {
        // check to see if parent app nodes or elements lies within any of the sub application
        // bounding boxes
        if (is_nodal)
        {
          for (auto & node : to_mesh->getMesh().node_ptr_range())
          {
            if (blockRestricted() && !hasBlocks(to_mesh, node))
              continue;

            if (boundaryRestricted() && !isBoundaryNode(to_mesh, node))
              continue;

            if (node->n_dofs(to_sys_num, to_var_num) > 0)
            {
              const auto transformed_node = to_transform(*node);

              unsigned int node_found_in_sub_app = 0;
              for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
              {
                if (!getFromMultiApp()->hasLocalApp(i))
                  continue;

                BoundingBox app_box = getFromMultiApp()->getBoundingBox(
                    i, _displaced_source_mesh, _from_transforms[i].get());

                if (app_box.contains_point(transformed_node))
                  ++node_found_in_sub_app;
              }

              if (node_found_in_sub_app == 0)
                mooseError("MultiAppUserObjectTransfer: Parent app node ",
                           transformed_node,
                           " not found within the bounding box of any of the sub applications.");
              else if (node_found_in_sub_app > 1)
                mooseError("MultiAppUserObjectTransfer: Parent app node ",
                           transformed_node,
                           " found within the bounding box of two or more sub applications.");
            }
          }
        }
        else // elemental
        {
          std::vector<Point> points;
          for (auto & elem :
               as_range(to_mesh->getMesh().elements_begin(), to_mesh->getMesh().elements_end()))
          {
            if (blockRestricted() && !hasBlocks(elem))
              continue;

            if (boundaryRestricted() && !isBoundaryElem(to_mesh, elem))
              continue;

            // Skip this element if the variable has no dofs at it.
            if (elem->n_dofs(to_sys_num, to_var_num) < 1)
              continue;

            points.clear();
            // grap sample points
            // for constant shape function, we take the element centroid
            if (is_constant)
              points.push_back(to_transform(elem->vertex_average()));
            // for higher order method, we take all nodes of element
            // this works for the first order L2 Lagrange.
            else
              for (auto & node : elem->node_ref_range())
                points.push_back(to_transform(node));

            auto n_points = points.size();
            unsigned int n_comp = elem->n_comp(to_sys_num, to_var_num);
            // We assume each point corresponds to one component of elemental variable
            if (n_points != n_comp)
              mooseError(" Number of points ",
                         n_points,
                         " does not equal to number of variable components ",
                         n_comp);

            for (auto & point : points)
            {
              unsigned int elem_found_in_sub_app = 0;

              for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
              {
                if (!getFromMultiApp()->hasLocalApp(i))
                  continue;

                BoundingBox app_box = getFromMultiApp()->getBoundingBox(
                    i, _displaced_source_mesh, _from_transforms[i].get());

                if (app_box.contains_point(point))
                  ++elem_found_in_sub_app;
              }

              if (elem_found_in_sub_app == 0)
                mooseError("MultiAppUserObjectTransfer: Parent app element with ",
                           n_points > 1 ? "node" : "centroid",
                           " at ",
                           point,
                           " not found within the bounding box of any of the sub applications.");

              else if (elem_found_in_sub_app > 1)
                mooseError("MultiAppUserObjectTransfer: Parent app element with ",
                           n_points > 1 ? "node" : "centroid",
                           " at ",
                           point,
                           " found within the bounding box of two or more sub applications.");
            }
          }
        }
      }

      if (is_nodal)
      {
        for (auto & node : to_mesh->getMesh().node_ptr_range())
        {
          if (blockRestricted() && !hasBlocks(to_mesh, node))
            continue;

          if (boundaryRestricted() && !isBoundaryNode(to_mesh, node))
            continue;

          if (node->n_dofs(to_sys_num, to_var_num) > 0) // If this variable has dofs at this node
          {
            const auto transformed_node = to_transform(*node);
            const auto sub_app = findSubAppToTransferFrom(transformed_node);

            // Check to see if a sub-app was found
            if (sub_app == static_cast<unsigned int>(-1))
              continue;

            const auto & from_transform = *_from_transforms[sub_app];
            const auto & user_object = _multi_app->appUserObjectBase(sub_app, _user_object_name);

            dof_id_type dof = node->dof_number(to_sys_num, to_var_num, 0);

            Real from_value = 0;
            {
              Moose::ScopedCommSwapper swapper(getFromMultiApp()->comm());
              from_value = user_object.spatialValue(from_transform.mapBack(transformed_node));
            }

            if (from_value == std::numeric_limits<Real>::infinity())
              mooseError("MultiAppUserObjectTransfer: Point corresponding to parent app node at (",
                         transformed_node,
                         ") not found in the sub application.");
            to_solution->set(dof, from_value);
          }
        }
      }
      else // Elemental
      {
        std::vector<Point> points;
        for (auto & elem :
             as_range(to_mesh->getMesh().elements_begin(), to_mesh->getMesh().elements_end()))
        {
          if (blockRestricted() && !hasBlocks(elem))
            continue;

          if (boundaryRestricted() && !isBoundaryElem(to_mesh, elem))
            continue;

          // Skip this element if the variable has no dofs at it.
          if (elem->n_dofs(to_sys_num, to_var_num) < 1)
            continue;

          points.clear();
          // grap sample points
          // for constant shape function, we take the element centroid
          if (is_constant)
            points.push_back(to_transform(elem->vertex_average()));
          // for higher order method, we take all nodes of element
          // this works for the first order L2 Lagrange.
          else
            for (auto & node : elem->node_ref_range())
              points.push_back(to_transform(node));

          auto n_points = points.size();
          unsigned int n_comp = elem->n_comp(to_sys_num, to_var_num);
          // We assume each point corresponds to one component of elemental variable
          if (n_points != n_comp)
            mooseError(" Number of points ",
                       n_points,
                       " does not equal to number of variable components ",
                       n_comp);

          unsigned int offset = 0;
          for (auto & point : points) // If this variable has dofs at this elem
          {
            const auto sub_app = findSubAppToTransferFrom(point);

            // Check to see if a sub-app was found
            if (sub_app == static_cast<unsigned int>(-1))
              continue;

            const auto & from_transform = *_from_transforms[sub_app];
            const auto & user_object =
                getFromMultiApp()->appUserObjectBase(sub_app, _user_object_name);

            dof_id_type dof = elem->dof_number(to_sys_num, to_var_num, offset++);

            Real from_value = 0;
            {
              Moose::ScopedCommSwapper swapper(getFromMultiApp()->comm());
              from_value = user_object.spatialValue(from_transform.mapBack(point));
            }

            if (from_value == std::numeric_limits<Real>::infinity())
              mooseError("MultiAppUserObjectTransfer: Point corresponding to element's centroid (",
                         point,
                         ") not found in sub application.");

            to_solution->set(dof, from_value);
          }
        }
      }

      to_solution->close();
      to_sys.update();

      break;
    }
  }

  postExecute();
}

extendBoundingBoxes()

void MultiAppTransfer::extendBoundingBoxes ( const Real  factor, std::vector< libMesh::BoundingBox > &  bboxes  ) const

protectedinherited

Extends bounding boxes to avoid missing points.

Definition at line 451 of file MultiAppTransfer.C.

Referenced by MultiAppTransfer::getFromBoundingBoxes(), and MultiAppGeneralFieldTransfer::prepareToTransfer().

{
  const auto extension_factor = factor - 1;

  // Extend (or contract if the extension factor is negative) bounding boxes along all the
  // directions by the same length. Greater than zero values of this member may be necessary because
  // the nearest bounding box does not necessarily give you the closest node/element. It will depend
  // on the partition and geometry. A node/element will more likely find its nearest source
  // element/node by extending bounding boxes. If each of the bounding boxes covers the entire
  // domain, a node/element will be able to find its nearest source element/node for sure, but at
  // the same time, more communication will be involved and can be expensive.
  for (auto & box : bboxes)
  {
    // libmesh set an invalid bounding box using this code
    // for (unsigned int i=0; i<LIBMESH_DIM; i++)
    // {
    //   this->first(i)  =  std::numeric_limits<Real>::max();
    //   this->second(i) = -std::numeric_limits<Real>::max();
    // }
    // If it is an invalid box, we should skip it
    if (box.first(0) == std::numeric_limits<Real>::max())
      continue;

    auto width = box.second - box.first;
    box.second += width * extension_factor;
    box.first -= width * extension_factor;
  }
}

find_sys()

System * Transfer::find_sys ( libMesh::EquationSystems &  es, const std::string &  var_name  )

staticinherited

Small helper function for finding the system containing the variable.

Note that this implies that variable names are unique across all systems!

Parameters

es	The EquationSystems object to be searched.
var_name	The name of the variable you are looking for.

Note that this implies that variable names are unique across all systems!

Definition at line 91 of file Transfer.C.

Referenced by MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::execute(), execute(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), and MultiAppShapeEvaluationTransfer::transferVariable().

{
  // Find the system this variable is from
  for (unsigned int i = 0; i < es.n_systems(); i++)
    if (es.get_system(i).has_variable(var_name))
      return &es.get_system(i);

  ::mooseError("Unable to find variable " + var_name + " in any system.");

  // Unreachable
  return &es.get_system(0);
}

findSubAppToTransferFrom()

unsigned int MultiAppUserObjectTransfer::findSubAppToTransferFrom ( const Point &  p )

protected

Gets the UserObject to transfer from when transferring from_multiapp.

Parameters

p	The point in the parent app that is being transferred to

Returns

the subapp index, will return static_cast<unsigned int>(-1) if none is found

Definition at line 605 of file MultiAppUserObjectTransfer.C.

Referenced by execute().

{
  // Just find the nearest app to this point
  if (_nearest_sub_app)
  {
    unsigned int closest_app = 0;
    Real closest_distance = std::numeric_limits<Real>::max();

    mooseAssert(_multi_app->numGlobalApps() > 0, "No Multiapps To Transfer From");

    for (unsigned int i = 0; i < _multi_app->numGlobalApps(); i++)
    {
      // Obtain the possibly transformed app position by querying the transform with the origin
      const auto app_position = _multi_app->runningInPosition()
                                    ? (*_from_transforms[i])(_multi_app->position(i))
                                    : (*_from_transforms[i])(Point(0));

      auto distance = (p - app_position).norm();

      if (distance < closest_distance)
      {
        closest_app = i;
        closest_distance = distance;
      }
    }

    // We can only get the value if we have this app
    // otherwise - another processor will set it
    if (_multi_app->hasLocalApp(closest_app))
      return closest_app;
    else
      return -1;
  }

  // Find the app that contains this point...

  // This loop counts _down_ so that it can preserve legacy behavior of the
  // last sub-app "winning" to be able to set the value at this point
  for (int i = _multi_app->numGlobalApps() - 1; i >= 0; i--)
  {
    if (!_multi_app->hasLocalApp(i))
      continue;

    BoundingBox app_box =
        _multi_app->getBoundingBox(i, _displaced_source_mesh, _from_transforms[i].get());

    if (_skip_bbox_check || app_box.contains_point(p))
      return static_cast<unsigned int>(i);
  }

  return -1;
}

getAppInfo()

void MultiAppTransfer::getAppInfo ( )

virtualinherited

This method will fill information into the convenience member variables (_to_problems, _from_meshes, etc.)

Reimplemented in MultiAppGeneralFieldTransfer.

Definition at line 228 of file MultiAppTransfer.C.

Referenced by execute(), MultiAppGeneralFieldTransfer::getAppInfo(), and MultiAppTransfer::initialSetup().

{
  // I would like to do all of this in initialSetup, but it will fail with
  // multiapps that reset.  A reset deletes and rebuilds the FEProblems so all
  // of the pointers will be broken.

  // Clear the vectors since we've probably built them up from a previous call
  _from_problems.clear();
  _to_problems.clear();
  _from_es.clear();
  _to_es.clear();
  _from_meshes.clear();
  _to_meshes.clear();
  _to_positions.clear();
  _from_positions.clear();
  _to_transforms.clear();
  _from_transforms.clear();
  // Clear this map since we build it from scratch every time we transfer
  // Otherwise, this will cause two issues: 1) increasing memory usage
  // for a simulation that requires many transfers, 2) producing wrong results
  // when we do collective communication on this vector.
  _to_local2global_map.clear();
  _from_local2global_map.clear();

  // Build the vectors for to problems, from problems, and subapps positions.
  if (_current_direction == FROM_MULTIAPP)
  {
    _to_problems.push_back(&_from_multi_app->problemBase());
    _to_positions.push_back(Point(0., 0., 0.));
    getFromMultiAppInfo();
  }
  else if (_current_direction == TO_MULTIAPP)
  {
    _from_problems.push_back(&_to_multi_app->problemBase());
    _from_positions.push_back(Point(0., 0., 0.));
    getToMultiAppInfo();
  }
  else if (_current_direction == BETWEEN_MULTIAPP)
  {
    mooseAssert(&_from_multi_app->problemBase().coordTransform() ==
                    &_to_multi_app->problemBase().coordTransform(),
                "I believe these should be the same. If not, then it will be difficult to define a "
                "canonical reference frame.");
    getToMultiAppInfo();
    getFromMultiAppInfo();
  }

  // Build the from and to equation systems and mesh vectors.
  for (unsigned int i = 0; i < _to_problems.size(); i++)
  {
    // TODO: Do I actually want es or displaced es?
    _to_es.push_back(&_to_problems[i]->es());
    if (_displaced_target_mesh && _to_problems[i]->getDisplacedProblem())
      _to_meshes.push_back(&_to_problems[i]->getDisplacedProblem()->mesh());
    else
      _to_meshes.push_back(&_to_problems[i]->mesh());
  }

  for (unsigned int i = 0; i < _from_problems.size(); i++)
  {
    _from_es.push_back(&_from_problems[i]->es());
    if (_displaced_source_mesh && _from_problems[i]->getDisplacedProblem())
      _from_meshes.push_back(&_from_problems[i]->getDisplacedProblem()->mesh());
    else
      _from_meshes.push_back(&_from_problems[i]->mesh());
  }

  MooseAppCoordTransform::MinimalData from_app_transform_construction_data{};
  if (_communicator.rank() == 0)
    from_app_transform_construction_data =
        _current_direction == TO_MULTIAPP
            ? _to_multi_app->problemBase().coordTransform().minimalDataDescription()
            : _from_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
  _communicator.broadcast(from_app_transform_construction_data);
  _from_moose_app_transform =
      std::make_unique<MooseAppCoordTransform>(from_app_transform_construction_data);

  MooseAppCoordTransform::MinimalData to_app_transform_construction_data{};
  if (_communicator.rank() == 0)
    to_app_transform_construction_data =
        _current_direction == FROM_MULTIAPP
            ? _from_multi_app->problemBase().coordTransform().minimalDataDescription()
            : _to_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
  _communicator.broadcast(to_app_transform_construction_data);
  _to_moose_app_transform =
      std::make_unique<MooseAppCoordTransform>(to_app_transform_construction_data);

  /*
   * skip_coordinate_collapsing: whether to set the transform to skip coordinate collapsing
   *                             (from XYZ to RZ for example)
   * transforms: vector of transforms to add the new transforms to
   * moose_app_transform: base for the new transform
   * is_parent_app_transform: whether working on the transform for the parent app (this app, the
   *                          one creating the transfer) or for child apps
   * multiapp: pointer to the multiapp to obtain the position of the child apps
   */
  auto create_multiapp_transforms = [this](auto & transforms,
                                           const auto & moose_app_transform,
                                           const bool is_parent_app_transform,
                                           const MultiApp * const multiapp = nullptr)
  {
    mooseAssert(is_parent_app_transform || multiapp,
                "Coordinate transform must be created either for child app or parent app");
    if (is_parent_app_transform)
    {
      transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
      transforms.back()->skipCoordinateCollapsing(_skip_coordinate_collapsing);
      // zero translation
    }
    else
    {
      mooseAssert(transforms.size() == 0, "transforms should not be initialized at this point");
      for (const auto i : make_range(multiapp->numGlobalApps()))
      {
        transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
        auto & transform = transforms[i];
        transform->skipCoordinateCollapsing(_skip_coordinate_collapsing);
        if (multiapp->usingPositions())
          transform->setTranslationVector(multiapp->position(i));
      }
    }
  };

  if (_current_direction == TO_MULTIAPP)
  {
    create_multiapp_transforms(
        _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
    create_multiapp_transforms(_from_transforms, *_from_moose_app_transform, true);
  }
  if (_current_direction == FROM_MULTIAPP)
  {
    create_multiapp_transforms(_to_transforms, *_to_moose_app_transform, true);
    create_multiapp_transforms(
        _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
  }
  if (_current_direction == BETWEEN_MULTIAPP)
  {
    create_multiapp_transforms(
        _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
    create_multiapp_transforms(
        _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
  }

  auto check_transform_compatibility = [this](const MultiAppCoordTransform & transform)
  {
    if (transform.hasNonTranslationTransformation() && !usesMooseAppCoordTransform())
      mooseWarning("Transfer '",
                   name(),
                   "' of type '",
                   type(),
                   "' has non-translation transformations but it does not implement coordinate "
                   "transformations using the 'MooseAppCoordTransform' class. Your data transfers "
                   "will not be performed in the expected transformed frame");
  };

  // set the destination coordinate systems for each transform for the purposes of determining
  // coordinate collapsing. For example if TO is XYZ and FROM is RZ, then TO will have its XYZ
  // coordinates collapsed into RZ and FROM will have a no-op for coordinate collapsing

  for (const auto i : index_range(_from_transforms))
  {
    auto & from_transform = _from_transforms[i];
    from_transform->setDestinationCoordTransform(*_to_moose_app_transform);
    if (i == 0)
      check_transform_compatibility(*from_transform);
  }
  for (const auto i : index_range(_to_transforms))
  {
    auto & to_transform = _to_transforms[i];
    to_transform->setDestinationCoordTransform(*_from_moose_app_transform);
    if (i == 0)
      check_transform_compatibility(*to_transform);
  }
}

getCheckedPointerParam()

template<typename T >

T MooseBaseParameterInterface::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 268 of file MooseBaseParameterInterface.h.

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

getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_path);
}

getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

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

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

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

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

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

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

  return found_path.path;
}

getEquationSystem()

EquationSystems & MultiAppFieldTransfer::getEquationSystem ( FEProblemBase &  problem, bool  use_displaced  ) const

protectedinherited

Returns the Problem's equation system, displaced or not Be careful! If you transfer TO a displaced system you will likely need a synchronization So most transfers reach the non-displaced system directly.

Definition at line 55 of file MultiAppFieldTransfer.C.

Referenced by MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), and MultiAppShapeEvaluationTransfer::transferVariable().

{
  if (use_displaced)
  {
    if (!problem.getDisplacedProblem())
      mooseError("No displaced problem to provide a displaced equation system");
    return problem.getDisplacedProblem()->es();
  }
  else
    return problem.es();
}

getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const

inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 66 of file SetupInterface.C.

Referenced by MultiAppTransfer::checkMultiAppExecuteOn(), EigenProblem::checkProblemIntegrity(), EigenExecutionerBase::init(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), ElementReporter::shouldStore(), NodalReporter::shouldStore(), and GeneralReporter::shouldStore().

{
  return _execute_enum;
}

getFromBoundingBoxes() [1/2]

std::vector< BoundingBox > MultiAppTransfer::getFromBoundingBoxes ( )

protectedinherited

Return the bounding boxes of all the "from" domains, including all the domains not local to this processor.

There is a boundary restricted version which will return a degenerate minimum boundary box (min, min, min, min, min, min) in the case where the source domain doesn't have any active nodes on the boundary. Note: bounding boxes are in the reference space when using coordinate transformations / positions Note: global bounding boxes are not indexed by app number. But rather outer indexing is by process, then the inner indexing is by local app number.

Definition at line 481 of file MultiAppTransfer.C.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), and MultiAppShapeEvaluationTransfer::transferVariable().

{
  std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
  for (unsigned int i = 0; i < _from_meshes.size(); i++)
  {
    // Get a bounding box around the mesh elements that are local to the current
    // processor.
    BoundingBox bbox = MeshTools::create_local_bounding_box(*_from_meshes[i]);

    // Translate the bounding box to the from domain's position. We may have rotations so we must
    // be careful in constructing the new min and max (first and second)
    const auto from_global_num = getGlobalSourceAppIndex(i);
    transformBoundingBox(bbox, *_from_transforms[from_global_num]);

    // Cast the bounding box into a pair of points (so it can be put through
    // MPI communication).
    bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
  }

  // Serialize the bounding box points.
  _communicator.allgather(bb_points);

  // Recast the points back into bounding boxes and return.
  std::vector<BoundingBox> bboxes(bb_points.size());
  for (unsigned int i = 0; i < bb_points.size(); i++)
    bboxes[i] = static_cast<BoundingBox>(bb_points[i]);

  // possibly extend bounding boxes
  extendBoundingBoxes(_bbox_factor, bboxes);

  return bboxes;
}

getFromBoundingBoxes() [2/2]

std::vector< BoundingBox > MultiAppTransfer::getFromBoundingBoxes ( BoundaryID  boundary_id )

protectedinherited

Definition at line 515 of file MultiAppTransfer.C.

{
  std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
  const Real min_r = std::numeric_limits<Real>::lowest();
  const Real max_r = std::numeric_limits<Real>::max();

  for (unsigned int i = 0; i < _from_meshes.size(); i++)
  {

    Point min(max_r, max_r, max_r);
    Point max(min_r, min_r, min_r);
    bool at_least_one = false;

    // TODO: Factor this into mesh_tools after adding new boundary bounding box routine.
    const ConstBndNodeRange & bnd_nodes = *_from_meshes[i]->getBoundaryNodeRange();
    for (const auto & bnode : bnd_nodes)
    {
      if (bnode->_bnd_id == boundary_id &&
          bnode->_node->processor_id() == _from_meshes[i]->processor_id())
      {
        at_least_one = true;
        const auto & node = *bnode->_node;
        for (const auto i : make_range(Moose::dim))
        {
          min(i) = std::min(min(i), node(i));
          max(i) = std::max(max(i), node(i));
        }
      }
    }

    BoundingBox bbox(min, max);
    if (!at_least_one)
      bbox.min() = max; // If we didn't hit any nodes, this will be _the_ minimum bbox
    else
    {
      // Translate the bounding box to the from domain's position. We may have rotations so we must
      // be careful in constructing the new min and max (first and second)
      const auto from_global_num = getGlobalSourceAppIndex(i);
      transformBoundingBox(bbox, *_from_transforms[from_global_num]);
    }

    // Cast the bounding box into a pair of points (so it can be put through
    // MPI communication).
    bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
  }

  // Serialize the bounding box points.
  _communicator.allgather(bb_points);

  // Recast the points back into bounding boxes and return.
  std::vector<BoundingBox> bboxes(bb_points.size());
  for (unsigned int i = 0; i < bb_points.size(); i++)
    bboxes[i] = static_cast<BoundingBox>(bb_points[i]);

  // possibly extend bounding boxes
  extendBoundingBoxes(_bbox_factor, bboxes);

  return bboxes;
}

getFromMultiApp()

const std::shared_ptr<MultiApp> MultiAppTransfer::getFromMultiApp ( ) const

inlineinherited

Get the MultiApp to transfer data from.

Definition at line 63 of file MultiAppTransfer.h.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), execute(), MultiAppCloneReporterTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeToMultiapp(), MultiAppReporterTransfer::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::locatePointReceivers(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppUserObjectTransfer(), MultiAppConservativeTransfer::postExecute(), and MultiAppVariableValueSamplePostprocessorTransfer::setupPostprocessorCommunication().

  {
    if (!_from_multi_app)
      mooseError(
          "A from_multiapp was requested but is unavailable. Check the from_multi_app parameter");
    else
      return _from_multi_app;
  }

getFromName()

std::string MultiAppTransfer::getFromName ( ) const

inlineinherited

Get the name of thing being transferred from.

Returns

the name of the multiapp or "Parent"

Definition at line 86 of file MultiAppTransfer.h.

  {
    if (_from_multi_app)
      return _from_multi_app->name();
    else
      return "Parent";
  }

getFromsPerProc()

std::vector< unsigned int > MultiAppTransfer::getFromsPerProc ( )

protectedinherited

Return the number of "from" domains that each processor owns.

Note: same indexing as getFromBoundingBoxes

Definition at line 576 of file MultiAppTransfer.C.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppGeneralFieldTransfer::prepareToTransfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

{
  std::vector<unsigned int> froms_per_proc;
  if (_to_multi_app)
    froms_per_proc.resize(n_processors(), 1);
  if (_from_multi_app)
  {
    froms_per_proc.resize(n_processors());
    _communicator.allgather(_from_multi_app->numLocalApps(), froms_per_proc);
  }
  return froms_per_proc;
}

getFromVarNames()

virtual std::vector<VariableName> MultiAppConservativeTransfer::getFromVarNames ( ) const

inlineoverrideprotectedvirtualinherited

Virtual function defining variables to be transferred.

Implements MultiAppFieldTransfer.

Definition at line 34 of file MultiAppConservativeTransfer.h.

{ return _from_var_names; }

getGlobalSourceAppIndex()

unsigned int MultiAppTransfer::getGlobalSourceAppIndex ( unsigned int  i_from ) const

protectedinherited

Return the global app index from the local index in the "from-multiapp" transfer direction.

Definition at line 633 of file MultiAppTransfer.C.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldTransfer::acceptPointMeshDivision(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppGeneralFieldNearestLocationTransfer::getPointInLocalSourceFrame(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), and MultiAppGeneralFieldTransfer::initialSetup().

{
  mooseAssert(_current_direction == TO_MULTIAPP || i_from < _from_local2global_map.size(),
              "Out of bounds local from-app index");
  return _current_direction == TO_MULTIAPP ? 0 : _from_local2global_map[i_from];
}

getGlobalTargetAppIndex()

unsigned int MultiAppTransfer::getGlobalTargetAppIndex ( unsigned int  i_to ) const

protectedinherited

Return the global app index from the local index in the "to-multiapp" transfer direction.

Definition at line 641 of file MultiAppTransfer.C.

Referenced by MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), MultiAppGeneralFieldTransfer::cacheOutgoingPointInfo(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), MultiAppTransfer::getPointInTargetAppFrame(), MultiAppGeneralFieldTransfer::locatePointReceivers(), and MultiAppGeneralFieldTransfer::setSolutionVectorValues().

{
  mooseAssert(_current_direction == FROM_MULTIAPP || i_to < _to_local2global_map.size(),
              "Out of bounds local to-app index");
  return _current_direction == FROM_MULTIAPP ? 0 : _to_local2global_map[i_to];
}

getLocalSourceAppIndex()

unsigned int MultiAppTransfer::getLocalSourceAppIndex ( unsigned int  i_from ) const

protectedinherited

Return the local app index from the global index in the "from-multiapp" transfer direction We use the fact that global app indexes are consecutive on a given rank.

Definition at line 649 of file MultiAppTransfer.C.

{
  return _current_direction == TO_MULTIAPP
             ? 0
             : _from_local2global_map[i_from] - _from_local2global_map[0];
}

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

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

{ return _app; }

getMultiApp()

const std::shared_ptr<MultiApp> MultiAppTransfer::getMultiApp ( ) const

inlineinherited

Use this getter to obtain the MultiApp for transfers with a single direction.

Definition at line 48 of file MultiAppTransfer.h.

Referenced by MultiAppCloneReporterTransfer::initialSetup().

  {
    if (_from_multi_app && _to_multi_app && _from_multi_app != _to_multi_app)
      mooseError("Unclear which app you want to retrieve from Transfer ", name());
    else if (_from_multi_app)
      return _from_multi_app;
    else if (_to_multi_app)
      return _to_multi_app;
    else if (_multi_app)
      return _multi_app;
    else
      mooseError("Should not get here, there should be a multiapp");
  }

getParam() [1/2]

template<typename T >

const T & MooseBaseParameterInterface::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 204 of file MooseBaseParameterInterface.h.

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

{
  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0), &_moose_base);
}

getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBaseParameterInterface::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 261 of file MooseBaseParameterInterface.h.

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

getPointInTargetAppFrame()

Point MultiAppTransfer::getPointInTargetAppFrame ( const Point &  p, unsigned int  local_i_to, const std::string &  phase  ) const

protectedinherited

Get the target app point from a point in the reference frame.

Parameters

p	the point in the reference frame
local_i_to	the local target problem into
phase	the phase of the transfer where this is being attempted in case we have to output an info message that the coordinate collapse is not being applied

Returns

the point in the target app frame

Definition at line 612 of file MultiAppTransfer.C.

Referenced by MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), and MultiAppGeneralFieldTransfer::examineLocalValueConflicts().

{
  const auto & to_transform = _to_transforms[getGlobalTargetAppIndex(local_i_to)];
  if (to_transform->hasCoordinateSystemTypeChange())
  {
    if (!_skip_coordinate_collapsing)
      mooseInfo(phase + " cannot use the point in the target app frame due to the "
                        "non-uniqueness of the coordinate collapsing reverse mapping."
                        " Coordinate collapse is ignored for this operation");
    to_transform->skipCoordinateCollapsing(true);
    const auto target_point = to_transform->mapBack(p);
    to_transform->skipCoordinateCollapsing(false);
    return target_point;
  }
  else
    return to_transform->mapBack(p);
}

getRenamedParam()

template<typename T >

const T & MooseBaseParameterInterface::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 211 of file MooseBaseParameterInterface.h.

{
  // this enables having a default on the new parameter but bypassing it with the old one
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
  // Second most: accept old parameter
  else if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
  // Third most: accept default for new parameter
  else if (isParamValid(new_name) && !isParamValid(old_name))
    return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
  // Refuse: no default, no value passed
  else if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
               "' is being retrieved without being set.\n"
               "Did you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
               "' may not be provided alongside former parameter '" + old_name + "'");
}

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 287 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 68 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const

inherited

Definition at line 81 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

getToMultiApp()

const std::shared_ptr<MultiApp> MultiAppTransfer::getToMultiApp ( ) const

inlineinherited

Get the MultiApp to transfer data to.

Definition at line 73 of file MultiAppTransfer.h.

Referenced by MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), execute(), MultiAppReporterTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeToMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppUserObjectTransfer(), and MultiAppConservativeTransfer::postExecute().

  {
    if (!_to_multi_app)
      mooseError(
          "A to_multiapp was requested but is unavailable. Check the to_multi_app parameter");
    else
      return _to_multi_app;
  }

getToName()

std::string MultiAppTransfer::getToName ( ) const

inlineinherited

Get the name of thing being transferred to.

Returns

the name of the multiapp or "Parent"

Definition at line 98 of file MultiAppTransfer.h.

  {
    if (_to_multi_app)
      return _to_multi_app->name();
    else
      return "Parent";
  }

getToVarNames()

virtual std::vector<AuxVariableName> MultiAppConservativeTransfer::getToVarNames ( ) const

inlineoverrideprotectedvirtualinherited

Virtual function defining variables to transfer to.

Implements MultiAppFieldTransfer.

Definition at line 35 of file MultiAppConservativeTransfer.h.

{ return _to_var_names; }

getTransferVector()

NumericVector< Real > & MultiAppTransfer::getTransferVector ( unsigned int  i_local, std::string  var_name  )

protectedinherited

If we are transferring to a multiapp, return the appropriate solution vector.

Definition at line 590 of file MultiAppTransfer.C.

Referenced by MultiAppNearestNodeTransfer::execute(), and MultiAppShapeEvaluationTransfer::transferVariable().

{
  mooseAssert(_to_multi_app, "getTransferVector only works for transfers to multiapps");

  return _to_multi_app->appTransferVector(_to_local2global_map[i_local], var_name);
}

hasBlocks() [1/2]

bool MultiAppUserObjectTransfer::hasBlocks ( const Elem *  elem ) const

protected

Check that element 'elem' is part of the domain this transfer is restricted to.

Definition at line 568 of file MultiAppUserObjectTransfer.C.

Referenced by execute().

{
  return _blk_ids.find(elem->subdomain_id()) != _blk_ids.end();
}

hasBlocks() [2/2]

bool MultiAppUserObjectTransfer::hasBlocks ( const MooseMesh *  mesh, const Node *  node  ) const

protected

Check that Node 'node' belongs to block this transfer is restricted to.

Parameters

mesh	The mesh this transfer is active on
node	The node to check

Definition at line 574 of file MultiAppUserObjectTransfer.C.

{
  const auto & node_blk_ids = mesh->getNodeBlockIds(*node);
  std::set<SubdomainID> u;
  std::set_intersection(_blk_ids.begin(),
                        _blk_ids.end(),
                        node_blk_ids.begin(),
                        node_blk_ids.end(),
                        std::inserter(u, u.begin()));
  return !u.empty();
}

hasFromMultiApp()

bool MultiAppTransfer::hasFromMultiApp ( ) const

inlineinherited

Whether the transfer owns a non-null from_multi_app.

Definition at line 112 of file MultiAppTransfer.h.

Referenced by MultiAppPostprocessorTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppReporterTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeToMultiapp(), MultiAppReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), and MultiAppGeneralFieldTransfer::outputValueConflicts().

{ return !(!_from_multi_app); }

hasToMultiApp()

bool MultiAppTransfer::hasToMultiApp ( ) const

inlineinherited

Whether the transfer owns a non-null to_multi_app.

Definition at line 115 of file MultiAppTransfer.h.

Referenced by MultiAppReporterTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeToMultiapp(), MultiAppReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppGeneralFieldTransfer::outputValueConflicts(), and MultiAppGeneralFieldTransfer::setSolutionVectorValues().

{ return !(!_to_multi_app); }

initialSetup()

void MultiAppConservativeTransfer::initialSetup ( )

overridevirtualinherited

Method called at the beginning of the simulation for checking integrity or doing one-time setup.

Reimplemented from MultiAppFieldTransfer.

Reimplemented in MultiAppGeneralFieldTransfer, MultiAppProjectionTransfer, and MultiAppGeneralFieldNearestLocationTransfer.

Definition at line 117 of file MultiAppConservativeTransfer.C.

Referenced by MultiAppProjectionTransfer::initialSetup(), and MultiAppGeneralFieldTransfer::initialSetup().

{
  MultiAppFieldTransfer::initialSetup();
  if (_preserve_transfer)
  {
    if (_from_postprocessors_to_be_preserved.size() == 1 && _current_direction == TO_MULTIAPP)
    {
      FEProblemBase & from_problem = getToMultiApp()->problemBase();
      auto * pps = dynamic_cast<const NearestPointIntegralVariablePostprocessor *>(
          &(from_problem.getUserObjectBase(_from_postprocessors_to_be_preserved[0])));
      if (pps)
        _use_nearestpoint_pps = true;
      else
      {
        _use_nearestpoint_pps = false;
        if (getToMultiApp()->numGlobalApps() > 1)
          mooseError(
              " You have to specify ",
              getToMultiApp()->numGlobalApps(),
              " regular from-postprocessors, or use NearestPointIntegralVariablePostprocessor ");
      }
    }

    if (_to_postprocessors_to_be_preserved.size() == 1 && _current_direction == FROM_MULTIAPP)
    {
      FEProblemBase & to_problem = getFromMultiApp()->problemBase();
      auto * pps = dynamic_cast<const NearestPointIntegralVariablePostprocessor *>(
          &(to_problem.getUserObjectBase(_to_postprocessors_to_be_preserved[0])));
      if (pps)
        _use_nearestpoint_pps = true;
      else
      {
        _use_nearestpoint_pps = false;
        if (getFromMultiApp()->numGlobalApps() > 1)
          mooseError(
              " You have to specify ",
              getFromMultiApp()->numGlobalApps(),
              " regular to-postprocessors, or use NearestPointIntegralVariablePostprocessor ");
      }
    }

    const auto multi_app = hasFromMultiApp() ? getFromMultiApp() : getToMultiApp();

    // Let us check execute_on here. Users need to specify execute_on='transfer' in their input
    // files for the postprocessors that are used to compute the quantities to conserve in the
    // Parent app
    FEProblemBase & parent_problem = multi_app->problemBase();
    std::vector<PostprocessorName> pps_empty;
    // PPs for parent app
    auto & parent_app_pps =
        _current_direction == TO_MULTIAPP ? pps_empty : _to_postprocessors_to_be_preserved;
    for (auto & pp : parent_app_pps)
    {
      // Get out all execute_on options for parent app source pp
      auto & execute_on = parent_problem.getUserObjectBase(pp).getExecuteOnEnum();
      const auto & type = parent_problem.getUserObjectBase(pp).type();
      // Check if parent app has transfer execute_on
      if (!execute_on.isValueSet(EXEC_TRANSFER))
        mooseError(
            "execute_on='transfer' is required in the conservative transfer for " + type + " '",
            pp,
            "' computed in the parent application.\n"
            "Please add execute_on='transfer' to this postprocessor in the input file.\n"
            "For a custom postprocessor, make sure that execute_on options are not hardcoded.");
    }

    // Sub apps
    for (unsigned int i = 0; i < multi_app->numGlobalApps(); i++)
    {
      // If we do not have this app, we skip
      if (!multi_app->hasLocalApp(i))
        continue;
      // Sub problem for
      FEProblemBase & sub_problem = multi_app->appProblemBase(i);
      // PPs for this subapp
      auto & sub_pps =
          _current_direction == TO_MULTIAPP ? _to_postprocessors_to_be_preserved : pps_empty;
      for (auto & sub_pp : sub_pps)
      {
        // Get out of all execute_on options for sub pp
        auto & execute_on = sub_problem.getUserObjectBase(sub_pp).getExecuteOnEnum();
        const auto & type = sub_problem.getUserObjectBase(sub_pp).type();
        // Check if sub pp has transfer execute_on
        if (!execute_on.isValueSet(EXEC_TRANSFER))
          mooseError(
              "execute_on='transfer' is required in the conservative transfer for " + type + " '",
              sub_pp,
              "' in child application '" + multi_app->name() +
                  "'. \n"
                  "Please add execute_on='transfer' to this postprocessor in the input file.\n"
                  "For a custom postprocessor, make sure that execute_on options are not "
                  "hardcoded.");
      }
    }
  }
}

isBoundaryElem()

bool MultiAppUserObjectTransfer::isBoundaryElem ( const MooseMesh *  mesh, const Elem *  elem  ) const

protected

Check that the element belongs to boundary this transfer is restricted to.

Returns

true if the element belongs to the boundary this transfer is restricted to, false otherwise

Parameters

mesh	The mesh this transfer is active on
elem	The element to check

Definition at line 596 of file MultiAppUserObjectTransfer.C.

Referenced by execute().

{
  for (auto & bid : _bnd_ids)
    if (mesh->isBoundaryElem(elem->id(), bid))
      return true;
  return false;
}

isBoundaryNode()

bool MultiAppUserObjectTransfer::isBoundaryNode ( const MooseMesh *  mesh, const Node *  node  ) const

protected

Check that the node belongs to boundary this transfer is restricted to.

Returns

true if the node belongs to the boundary this transfer is restricted to, false otherwise

Parameters

mesh	The mesh this transfer is active on
node	The node to check

Definition at line 587 of file MultiAppUserObjectTransfer.C.

Referenced by execute().

{
  for (auto & bid : _bnd_ids)
    if (mesh->isBoundaryNode(node->id(), bid))
      return true;
  return false;
}

isParamSetByUser()

bool MooseBaseParameterInterface::isParamSetByUser ( const std::string &  nm ) const

inlineinherited

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

Parameters

nm	The name of the parameter to test

Definition at line 117 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), DiffusionCG::addSolverVariables(), LibtorchNeuralNetControl::conditionalParameterError(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), FixedPointSolve::FixedPointSolve(), MooseBaseParameterInterface::getRenamedParam(), DefaultNonlinearConvergence::getSharedExecutionerParam(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

{ return _pars.isParamSetByUser(nm); }

isParamValid()

bool MooseBaseParameterInterface::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 111 of file MooseBaseParameterInterface.h.

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

{ return _pars.isParamValid(name); }

jacobianSetup()

void SetupInterface::jacobianSetup ( )

virtualinherited

Gets called just before the Jacobian is computed and before this object is asked to do its job.

Reimplemented in MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< T >, MooseVariableFE< RealEigenVector >, MooseVariableFE< VectorValue< Real > >, MooseVariableFE< RealVectorValue >, MooseVariableFE< Real >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< RT >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, Positions, Times, ADKernelTempl< T >, and EqualValueEmbeddedConstraint.

Definition at line 51 of file SetupInterface.C.

Referenced by MooseVariableField< Real >::jacobianSetup(), and ComputeFVFluxJacobianThread< RangeType >::setup().

{
}

mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

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

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

mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Emits a documented error with object name and type.

Documented errors are errors that have an issue associated with them.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters

repo_name	The repository name where the issue resides
issue_num	The number of the issue
args	The error message to be combined

Definition at line 61 of file MooseBaseErrorInterface.h.

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

  {
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    const auto msg = moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str());
    _moose_base.callMooseError(msg, /* with_prefix = */ true);
  }

mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

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

  {
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    _moose_base.callMooseError(oss.str(), /* with_prefix = */ true);
  }

mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 40 of file MooseBaseErrorInterface.h.

  {
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    _moose_base.callMooseError(oss.str(), /* with_prefix = */ false);
  }

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 98 of file MooseBaseErrorInterface.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), FEProblemBase::setRestartFile(), and SymmetryTransformGenerator::SymmetryTransformGenerator().

  {
    moose::internal::mooseInfoStream(
        _console, _moose_base.errorPrefix("information"), std::forward<Args>(args)...);
  }

mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

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

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

mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 85 of file MooseBaseErrorInterface.h.

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

name()

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

inlinevirtualinherited

Get the name of the class.

Returns

The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

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

{ return _name; }

paramError()

template<typename... Args>

void MooseBaseParameterInterface::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 237 of file MooseBaseParameterInterface.h.

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

{
  Moose::show_trace = false;
  _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
                             /* with_prefix = */ false);
  Moose::show_trace = true;
}

parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

Referenced by AddDefaultConvergenceAction::act(), SetupDebugAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), FEProblemBase::addHDGIntegratedBC(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), OversampleOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainMeshGenerator::generate(), MooseBaseParameterInterface::getCheckedPointerParam(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), OverlayMeshGenerator::OverlayMeshGenerator(), PenetrationAux::PenetrationAux(), PicardSolve::PicardSolve(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), OutputWarehouse::resetFileBase(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SteffensenSolve::SteffensenSolve(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

{ return _pars; }

paramInfo()

template<typename... Args>

void MooseBaseParameterInterface::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 254 of file MooseBaseParameterInterface.h.

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

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

paramWarning()

template<typename... Args>

void MooseBaseParameterInterface::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 247 of file MooseBaseParameterInterface.h.

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

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

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

{
  return _pg_moose_app.perfGraph();
}

performAdjustment()

bool MultiAppConservativeTransfer::performAdjustment ( const PostprocessorValue &  from, const PostprocessorValue &  to  ) const

protectedinherited

Definition at line 526 of file MultiAppConservativeTransfer.C.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), and MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint().

{
  if (from * to > 0)
    return true;
  else if (_allow_skipped_adjustment)
    return false;
  else
    mooseError("Adjustment postprocessors from: ",
               from,
               " to: ",
               to,
               " must both have the same sign and be different from 0");
}

possibleDirections()

static std::string Transfer::possibleDirections ( )

inlinestaticinherited

Used to construct InputParameters.

Definition at line 76 of file Transfer.h.

Referenced by Transfer::validParams().

{ return "to_multiapp from_multiapp between_multiapp"; }

postExecute()

void MultiAppConservativeTransfer::postExecute ( )

virtualinherited

Add some extra work if necessary after execute().

For example, adjust the solution to preserve some physics quality of interest.

Reimplemented in MultiAppGeneralFieldTransfer.

Definition at line 215 of file MultiAppConservativeTransfer.C.

Referenced by MultiAppShapeEvaluationTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), execute(), and MultiAppGeneralFieldTransfer::postExecute().

{
  if (_preserve_transfer)
  {
    TIME_SECTION("MultiAppConservativeTransfer::execute()",
                 5,
                 "Post transfer to preserve postprocessor values");

    if (_current_direction == TO_MULTIAPP)
    {
      FEProblemBase & from_problem = getToMultiApp()->problemBase();
      if (_use_nearestpoint_pps)
        from_problem.computeUserObjectByName(
            EXEC_TRANSFER, Moose::POST_AUX, _from_postprocessors_to_be_preserved[0]);

      for (unsigned int i = 0; i < getToMultiApp()->numGlobalApps(); i++)
        if (getToMultiApp()->hasLocalApp(i))
        {
          if (_use_nearestpoint_pps)
            adjustTransferredSolutionNearestPoint(i,
                                                  &from_problem,
                                                  _from_postprocessors_to_be_preserved[0],
                                                  getToMultiApp()->appProblemBase(i),
                                                  _to_postprocessors_to_be_preserved[0]);
          else
            adjustTransferredSolution(&from_problem,
                                      _from_postprocessors_to_be_preserved[i],
                                      getToMultiApp()->appProblemBase(i),
                                      _to_postprocessors_to_be_preserved[0]);
        }
    }

    else if (_current_direction == FROM_MULTIAPP)
    {
      FEProblemBase & to_problem = getFromMultiApp()->problemBase();
      if (_use_nearestpoint_pps)
        to_problem.computeUserObjectByName(
            EXEC_TRANSFER, Moose::POST_AUX, _to_postprocessors_to_be_preserved[0]);

      for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
      {
        if (_use_nearestpoint_pps)
          adjustTransferredSolutionNearestPoint(
              i,
              getFromMultiApp()->hasLocalApp(i) ? &getFromMultiApp()->appProblemBase(i) : nullptr,
              _from_postprocessors_to_be_preserved[0],
              to_problem,
              _to_postprocessors_to_be_preserved[0]);
        else
          adjustTransferredSolution(
              getFromMultiApp()->hasLocalApp(i) ? &getFromMultiApp()->appProblemBase(i) : nullptr,
              _from_postprocessors_to_be_preserved[0],
              to_problem,
              _to_postprocessors_to_be_preserved[i]);
      }

      // Compute the to-postprocessor again so that it has the right value with the updated solution
      if (_use_nearestpoint_pps)
        to_problem.computeUserObjectByName(
            EXEC_TRANSFER, Moose::POST_AUX, _to_postprocessors_to_be_preserved[0]);
    }
  }
}

registerTimedSection() [1/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 53 of file PerfGraphInterface.C.

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

registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

Returns

The ID of the section - use when starting timing

Definition at line 64 of file PerfGraphInterface.C.

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

residualSetup()

void SetupInterface::residualSetup ( )

virtualinherited

Gets called just before the residual is computed and before this object is asked to do its job.

Reimplemented in MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< T >, MooseVariableFE< RealEigenVector >, MooseVariableFE< VectorValue< Real > >, MooseVariableFE< RealVectorValue >, MooseVariableFE< Real >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< RT >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, NodeFaceConstraint, Positions, and Times.

Definition at line 56 of file SetupInterface.C.

Referenced by MooseVariableField< Real >::residualSetup(), ComputeFVFluxResidualThread< RangeType >::setup(), and ComputeFVFluxRJThread< RangeType >::setup().

{
}

restartableName()

std::string Restartable::restartableName ( const std::string &  data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 66 of file Restartable.C.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

setCurrentDirection()

void Transfer::setCurrentDirection ( const int  direction )

inlineinherited

Set this Transfer to be executed in a given direction.

Definition at line 89 of file Transfer.h.

Referenced by FEProblemBase::execMultiAppTransfers().

  {
    _current_direction = direction;
    _direction = direction;
  }

subdomainSetup()

void SetupInterface::subdomainSetup ( )

virtualinherited

Gets called when the subdomain changes (i.e.

in a Jacobian or residual loop) and before this object is asked to do its job

Reimplemented in MaterialBase, Material, GeneralUserObject, NodalUserObject, Constraint, and ThreadedGeneralUserObject.

Definition at line 61 of file SetupInterface.C.

{
}

timedSectionName()

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

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

timestepSetup()

void SetupInterface::timestepSetup ( )

virtualinherited

Gets called at the beginning of the timestep before this object is asked to do its job.

Reimplemented in MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< RT >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, Function, Positions, Times, SolutionUserObjectBase, Console, VectorPostprocessorVisualizationAux, EqualValueEmbeddedConstraint, NumNonlinearIterations, VectorMemoryUsage, MemoryUsage, and JSONOutput.

Definition at line 46 of file SetupInterface.C.

Referenced by JSONOutput::timestepSetup(), and MooseVariableField< Real >::timestepSetup().

{
}

transformBoundingBox()

void MultiAppTransfer::transformBoundingBox ( libMesh::BoundingBox &  box, const MultiAppCoordTransform &  transform  )

staticprotectedinherited

Transform a bounding box according to the transformations in the provided coordinate transformation object.

Definition at line 445 of file MultiAppTransfer.C.

Referenced by MultiAppTransfer::getFromBoundingBoxes(), and MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes().

{
  MultiApp::transformBoundingBox(box, transform);
}

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

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

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

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

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

uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const

inlineinherited

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

Definition at line 67 of file MooseBaseParameterInterface.h.

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

  {
    return MooseObjectName(_pars.get<std::string>("_unique_name"));
  }

uniqueParameterName()

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

inlineinherited

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

Definition at line 52 of file MooseBaseParameterInterface.h.

  {
    return MooseObjectParameterName(
        _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
  }

usesMooseAppCoordTransform()

bool MultiAppUserObjectTransfer::usesMooseAppCoordTransform ( ) const

inlineoverrideprivatevirtual

Whether this transfer handles non-translation-based transformations, e.g.

whether it uses the MooseAppCoordTransform object

Reimplemented from MultiAppTransfer.

Definition at line 103 of file MultiAppUserObjectTransfer.h.

{ return true; }

validParams()

InputParameters MultiAppUserObjectTransfer::validParams ( )

static

Definition at line 33 of file MultiAppUserObjectTransfer.C.

{
  InputParameters params = MultiAppConservativeTransfer::validParams();
  //  MultiAppUserObjectTransfer does not need source variable since it query values from user
  //  objects
  params.set<std::vector<VariableName>>("source_variable") = std::vector<VariableName>{};
  params.suppressParameter<std::vector<VariableName>>("source_variable");
  params.addRequiredParam<UserObjectName>(
      "user_object",
      "The UserObject you want to transfer values from.  Note: This might be a "
      "UserObject from your MultiApp's input file!");
  params.addParam<bool>("all_parent_nodes_contained_in_sub_app",
                        false,
                        "Set to true if every parent app node is mapped to a distinct point on one "
                        "of the subApps during a transfer from sub App to Parent App. If parent app"
                        " node cannot be found within bounding boxes of any of the subApps, an "
                        " error is generated.");
  params.addDeprecatedParam<bool>(
      "all_master_nodes_contained_in_sub_app",
      "Set to true if every parent app node is mapped to a distinct point on one "
      "of the subApps during a transfer from sub App to Parent App. If parent app"
      " node cannot be found within bounding boxes of any of the subApps, an "
      " error is generated.",
      "all_master_nodes_contained_in_sub_app is deprecated. Use "
      "all_parent_nodes_contained_in_sub_app");
  params.addParam<bool>(
      "skip_bounding_box_check",
      false,
      "Skip the check if the to_elem is within the bounding box of the from_app.");
  params.addParam<std::vector<SubdomainName>>(
      "block", "The block we are transferring to (if not specified, whole domain is used).");
  params.addParam<std::vector<BoundaryName>>(
      "boundary",
      "The boundary we are transferring to (if not specified, whole domain is used unless 'block' "
      "parameter is used).");

  params.addClassDescription(
      "Samples a variable's value in the Parent app domain at the point where the MultiApp is and "
      "copies that value into a post-processor in the MultiApp");

  params.addParam<bool>("nearest_sub_app",
                        false,
                        "When True, a from_multiapp transfer will work by finding the nearest "
                        "(using the `location`) sub-app and query that for the value to transfer");
  return params;
}

variableIntegrityCheck()

void MultiAppTransfer::variableIntegrityCheck ( const AuxVariableName &  var_name, bool  is_from_multiapp  ) const

inherited

Utility to verify that the variable in the destination system exists.

Definition at line 182 of file MultiAppTransfer.C.

Referenced by MultiAppFieldTransfer::initialSetup(), and MultiAppVariableValueSampleTransfer::initialSetup().

{
  bool variable_found = false;
  bool has_an_app = false;

  // Check the from_multi_app for the variable
  if (is_from_multiapp && _from_multi_app)
    for (unsigned int i = 0; i < _from_multi_app->numGlobalApps(); i++)
      if (_from_multi_app->hasLocalApp(i))
      {
        has_an_app = true;
        if (_from_multi_app->appProblemBase(i).hasVariable(var_name))
          variable_found = true;
      }

  // Check the to_multi_app for the variable
  if (!is_from_multiapp && _to_multi_app)
    for (unsigned int i = 0; i < _to_multi_app->numGlobalApps(); i++)
      if (_to_multi_app->hasLocalApp(i))
      {
        has_an_app = true;
        if (_to_multi_app->appProblemBase(i).hasVariable(var_name))
          variable_found = true;
      }

  if (!variable_found && has_an_app)
    mooseError("Cannot find variable ", var_name, " for ", name(), " Transfer");
}

Member Data Documentation

_action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory

protectedinherited

Builds Actions.

Definition at line 168 of file MooseBaseParameterInterface.h.

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

_all_parent_nodes_contained_in_sub_app

const bool MultiAppUserObjectTransfer::_all_parent_nodes_contained_in_sub_app

protected

Boolean variable to generate error if every parent app node cannot be mapped to a subApp during from_multiapp transfer.

Definition at line 94 of file MultiAppUserObjectTransfer.h.

Referenced by execute().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

_bbox_factor

Real MultiAppTransfer::_bbox_factor

protectedinherited

Extend (or contract) bounding box by a factor in all directions Greater than one values of this member may be necessary because the nearest bounding box does not necessarily give you the closest node/element.

It will depend on the partition and geometry. A node/element will more likely find its nearest source element/node by extending bounding boxes. If each of the bounding boxes covers the entire domain, a node/element will be able to find its nearest source element/node for sure, but at the same time, more communication will be involved and can be expensive.

Definition at line 167 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::getFromBoundingBoxes().

_blk_ids

std::set<SubdomainID> MultiAppUserObjectTransfer::_blk_ids

private

Set of block ids this transfer is restricted to.

Definition at line 106 of file MultiAppUserObjectTransfer.h.

Referenced by blockRestricted(), execute(), and hasBlocks().

_bnd_ids

std::set<BoundaryID> MultiAppUserObjectTransfer::_bnd_ids

private

Set of the boundary ids.

Definition at line 109 of file MultiAppUserObjectTransfer.h.

Referenced by boundaryRestricted(), execute(), isBoundaryElem(), and isBoundaryNode().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

_current_direction

MooseEnum Transfer::_current_direction

protectedinherited

Definition at line 106 of file Transfer.h.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), Transfer::currentDirection(), MultiAppReporterTransfer::execute(), MultiAppCloneReporterTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppCopyTransfer::execute(), execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getGlobalSourceAppIndex(), MultiAppTransfer::getGlobalTargetAppIndex(), MultiAppTransfer::getLocalSourceAppIndex(), MultiAppConservativeTransfer::initialSetup(), MultiAppFieldTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppConservativeTransfer::postExecute(), Transfer::setCurrentDirection(), Transfer::Transfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

_current_execute_flag

const ExecFlagType& SetupInterface::_current_execute_flag

protectedinherited

Reference to FEProblemBase.

Definition at line 78 of file SetupInterface.h.

Referenced by PseudoTimestep::execute().

_direction

MooseEnum Transfer::_direction

protectedinherited

The current direction that is being executed for this Transfer. _direction is to be deprecated for _current_direction

Definition at line 105 of file Transfer.h.

Referenced by Transfer::direction(), MultiAppTransfer::MultiAppTransfer(), Transfer::setCurrentDirection(), and Transfer::Transfer().

_directions

MultiMooseEnum Transfer::_directions

protectedinherited

The directions this Transfer is to be executed on.

Definition at line 110 of file Transfer.h.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), Transfer::directions(), MultiAppReporterTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::setupPostprocessorCommunication(), and Transfer::Transfer().

_displaced_source_mesh

bool MultiAppTransfer::_displaced_source_mesh

protectedinherited

True if displaced mesh is used for the source mesh, otherwise false.

Definition at line 155 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), execute(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), findSubAppToTransferFrom(), MultiAppGeneralFieldTransfer::getAppInfo(), MultiAppTransfer::getAppInfo(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::prepareToTransfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

_displaced_target_mesh

bool MultiAppTransfer::_displaced_target_mesh

protectedinherited

True if displaced mesh is used for the target mesh, otherwise false.

Definition at line 157 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), execute(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), MultiAppTransfer::getAppInfo(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MultiAppGeneralFieldTransfer::prepareToTransfer(), and MultiAppGeneralFieldTransfer::setSolutionVectorValues().

_enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 51 of file MooseObject.h.

Referenced by MooseObject::enabled().

_execute_enum

const ExecFlagEnum& SetupInterface::_execute_enum

protectedinherited

Execute settings for this object.

Definition at line 75 of file SetupInterface.h.

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), SetupInterface::getExecuteOnEnum(), JSONOutput::outputReporters(), XMLOutput::outputVectorPostprocessors(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

_factory

Factory& MooseBaseParameterInterface::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 165 of file MooseBaseParameterInterface.h.

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

_fe_problem

FEProblemBase& Transfer::_fe_problem

protectedinherited

Definition at line 97 of file Transfer.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MultiAppGeneralFieldTransfer::closestToPosition(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::locatePointReceivers(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer(), and MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer().

_from_es

std::vector<libMesh::EquationSystems *> MultiAppTransfer::_from_es

protectedinherited

Definition at line 142 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::getAppInfo().

_from_local2global_map

std::vector<unsigned int> MultiAppTransfer::_from_local2global_map

protectedinherited

Given local app index, returns global app index.

Definition at line 199 of file MultiAppTransfer.h.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromMultiAppInfo(), MultiAppTransfer::getGlobalSourceAppIndex(), MultiAppGeneralFieldTransfer::getGlobalStartAppPerProc(), MultiAppTransfer::getLocalSourceAppIndex(), MultiAppGeneralFieldTransfer::outputValueConflicts(), and MultiAppShapeEvaluationTransfer::transferVariable().

_from_meshes

std::vector<MooseMesh *> MultiAppTransfer::_from_meshes

protectedinherited

Definition at line 144 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppNearestNodeTransfer::execute(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppGeneralFieldNearestLocationTransfer::getNumAppsPerTree(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), and MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes().

_from_positions

std::vector<Point> MultiAppTransfer::_from_positions

protectedinherited

Definition at line 146 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromMultiAppInfo(), and MultiAppGeneralFieldNearestLocationTransfer::getPointInLocalSourceFrame().

_from_postprocessors_to_be_preserved

std::vector<PostprocessorName> MultiAppConservativeTransfer::_from_postprocessors_to_be_preserved

protectedinherited

Postprocessor evaluates an adjuster for the source physics.

Definition at line 51 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppConservativeTransfer::initialSetup(), and MultiAppConservativeTransfer::postExecute().

_from_problems

std::vector<FEProblemBase *> MultiAppTransfer::_from_problems

protectedinherited

Definition at line 140 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppGeneralFieldTransfer::getAppInfo(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromMultiAppInfo(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::outputValueConflicts(), and MultiAppShapeEvaluationTransfer::transferVariable().

_from_transforms

std::vector<std::unique_ptr<MultiAppCoordTransform> > MultiAppTransfer::_from_transforms

protectedinherited

Definition at line 148 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), execute(), findSubAppToTransferFrom(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppGeneralFieldNearestLocationTransfer::getPointInLocalSourceFrame(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), and MultiAppShapeEvaluationTransfer::transferVariable().

_from_var_name

VariableName MultiAppConservativeTransfer::_from_var_name

protectedinherited

This values are used if a derived class only supports one variable.

Definition at line 45 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), and MultiAppGeometricInterpolationTransfer::execute().

_from_var_names

const std::vector<VariableName> MultiAppConservativeTransfer::_from_var_names

protectedinherited

Name of variables transferring from.

Definition at line 40 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), MultiAppGeneralFieldTransfer::getFromVarName(), MultiAppConservativeTransfer::getFromVarNames(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MultiAppShapeEvaluationTransfer::transferVariable(), and MultiAppGeneralFieldTransfer::transferVariable().

_multi_app

std::shared_ptr<MultiApp> MultiAppTransfer::_multi_app

protectedinherited

Deprecated class attribute for compatibility with the apps.

Definition at line 137 of file MultiAppTransfer.h.

Referenced by execute(), findSubAppToTransferFrom(), MultiAppTransfer::getMultiApp(), and MultiAppTransfer::MultiAppTransfer().

_name

const std::string MooseBase::_name

protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

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

_nearest_sub_app

const bool& MultiAppUserObjectTransfer::_nearest_sub_app

protected

Whether to utilize the nearest sub-app to transfer from.

Definition at line 100 of file MultiAppUserObjectTransfer.h.

Referenced by findSubAppToTransferFrom().

_pars

const InputParameters& MooseBaseParameterInterface::_pars

protectedinherited

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition at line 162 of file MooseBaseParameterInterface.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddVariableAction::act(), CommonOutputAction::act(), AddPeriodicBCAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), FVFluxKernel::adjustRMGhostLayers(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBaseParameterInterface::connectControllableParams(), Console::Console(), AddVariableAction::createInitialConditionAction(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FVAdvection::FVAdvection(), FVAnisotropicDiffusion::FVAnisotropicDiffusion(), FVDiffusion::FVDiffusion(), FileMeshGenerator::generate(), MaterialBase::getGenericZeroMaterialProperty(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBaseParameterInterface::getParam(), MooseBaseParameterInterface::getRenamedParam(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBaseParameterInterface::isParamSetByUser(), MooseBaseParameterInterface::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBaseParameterInterface::MooseBaseParameterInterface(), MooseBaseParameterInterface::paramErrorMsg(), GlobalParamsAction::parameters(), MooseBaseParameterInterface::parameters(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseBaseParameterInterface::uniqueName(), and MooseBaseParameterInterface::uniqueParameterName().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_preserve_transfer

bool MultiAppConservativeTransfer::_preserve_transfer

protectedinherited

If this transfer is going to conserve the physics.

Definition at line 49 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppConservativeTransfer::initialSetup(), and MultiAppConservativeTransfer::postExecute().

_restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 227 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

_restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 236 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 230 of file Restartable.h.

Referenced by Restartable::restartableName().

_restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 233 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

_skip_bbox_check

const bool MultiAppUserObjectTransfer::_skip_bbox_check

protected

whether to check the bounding box check or not

Definition at line 97 of file MultiAppUserObjectTransfer.h.

Referenced by findSubAppToTransferFrom().

_skip_coordinate_collapsing

const bool MultiAppTransfer::_skip_coordinate_collapsing

protectedinherited

Whether to skip coordinate collapsing (transformations of coordinates between applications using different frames of reference)

Definition at line 152 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppTransfer::getAppInfo(), MultiAppGeneralFieldNearestLocationTransfer::getPointInLocalSourceFrame(), MultiAppTransfer::getPointInTargetAppFrame(), and MultiAppGeneralFieldTransfer::outputValueConflicts().

_subproblem

SubProblem& Transfer::_subproblem

protectedinherited

Definition at line 96 of file Transfer.h.

_sys

SystemBase& Transfer::_sys

protectedinherited

Definition at line 98 of file Transfer.h.

_tid

THREAD_ID Transfer::_tid

protectedinherited

Definition at line 100 of file Transfer.h.

Referenced by MultiAppPostprocessorToAuxScalarTransfer::execute(), and MultiAppScalarToAuxScalarTransfer::execute().

_to_es

std::vector<libMesh::EquationSystems *> MultiAppTransfer::_to_es

protectedinherited

Definition at line 141 of file MultiAppTransfer.h.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppTransfer::getAppInfo(), and MultiAppShapeEvaluationTransfer::transferVariable().

_to_local2global_map

std::vector<unsigned int> MultiAppTransfer::_to_local2global_map

protectedinherited

Given local app index, returns global app index.

Definition at line 197 of file MultiAppTransfer.h.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getGlobalTargetAppIndex(), MultiAppTransfer::getToMultiAppInfo(), MultiAppTransfer::getTransferVector(), MultiAppGeneralFieldTransfer::outputValueConflicts(), and MultiAppShapeEvaluationTransfer::transferVariable().

_to_meshes

std::vector<MooseMesh *> MultiAppTransfer::_to_meshes

protectedinherited

Definition at line 143 of file MultiAppTransfer.h.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppTransfer::getAppInfo(), MultiAppGeneralFieldTransfer::getMaxToProblemsBBoxDimensions(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), MultiAppGeneralFieldTransfer::locatePointReceivers(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), and MultiAppShapeEvaluationTransfer::transferVariable().

_to_positions

std::vector<Point> MultiAppTransfer::_to_positions

protectedinherited

Definition at line 145 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::getAppInfo(), and MultiAppTransfer::getToMultiAppInfo().

_to_postprocessors_to_be_preserved

std::vector<PostprocessorName> MultiAppConservativeTransfer::_to_postprocessors_to_be_preserved

protectedinherited

Postprocessor evaluates an adjuster for the target physics.

Definition at line 53 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppConservativeTransfer::initialSetup(), and MultiAppConservativeTransfer::postExecute().

_to_problems

std::vector<FEProblemBase *> MultiAppTransfer::_to_problems

protectedinherited

Definition at line 139 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getToMultiAppInfo(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MultiAppProjectionTransfer::projectSolution(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), MultiAppShapeEvaluationTransfer::transferVariable(), and MultiAppGeneralFieldTransfer::transferVariable().

_to_transforms

std::vector<std::unique_ptr<MultiAppCoordTransform> > MultiAppTransfer::_to_transforms

protectedinherited

Definition at line 147 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), MultiAppGeneralFieldTransfer::cacheOutgoingPointInfo(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getPointInTargetAppFrame(), MultiAppGeneralFieldTransfer::locatePointReceivers(), MultiAppGeneralFieldTransfer::outputValueConflicts(), and MultiAppShapeEvaluationTransfer::transferVariable().

_to_var_name

AuxVariableName MultiAppConservativeTransfer::_to_var_name

protectedinherited

Definition at line 46 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppNearestNodeTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), execute(), MultiAppProjectionTransfer::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), and MultiAppProjectionTransfer::projectSolution().

_to_var_names

const std::vector<AuxVariableName> MultiAppConservativeTransfer::_to_var_names

protectedinherited

Name of variables transferring to.

Definition at line 42 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::getToVarName(), MultiAppConservativeTransfer::getToVarNames(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

_type

const std::string MooseBase::_type

protectedinherited

The type of this class.

Definition at line 87 of file MooseBase.h.

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

_user_object_name

std::string MultiAppUserObjectTransfer::_user_object_name

protected

Definition at line 88 of file MultiAppUserObjectTransfer.h.

Referenced by execute().

OutOfMeshValue

const Number Transfer::OutOfMeshValue = -999999

staticinherited

Definition at line 113 of file Transfer.h.

Referenced by MultiAppProjectionTransfer::execute(), and MultiAppShapeEvaluationTransfer::transferVariable().

---

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

• include/transfers/MultiAppUserObjectTransfer.h
• src/transfers/MultiAppUserObjectTransfer.C