MultiAppGeneralFieldTransfer Class Reference

It is a general field transfer. More...

#include <MultiAppGeneralFieldTransfer.h>

Inheritance diagram for MultiAppGeneralFieldTransfer:

Classes
struct	InterpInfo
	InterpInfo. More...
struct	PointInfo
	Point information. More...

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
	MultiAppGeneralFieldTransfer (const InputParameters &parameters)
virtual void	initialSetup () override
	Method called at the beginning of the simulation for checking integrity or doing one-time setup. More...
virtual void	getAppInfo () override
	This method will fill information into the convenience member variables (_to_problems, _from_meshes, etc.) More...
virtual void	execute () override
	Execute the transfer. More...
virtual void	postExecute () override
	Add some extra work if necessary after execute(). More...
VariableName	getFromVarName (unsigned int var_index)
	Get the source variable name, with the suffix for array/vector variables. More...
VariableName	getToVarName (unsigned int var_index)
	Get the target variable name, with the suffix for array/vector variables. 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...
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...
const std::string &	name () const
	Get the name of the class. More...
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
	Get the parameters of the object. More...
const hit::Node *	getHitNode () const
bool	hasBase () const
const std::string &	getBase () const
template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object. More...
template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object. More...
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...
bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...
template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
std::string	messagePrefix (const bool hit_prefix=true) const
std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used. More...
template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available. More...
template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError(). More...
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
	External method for calling moose error with added object context. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
std::string	getDataFileName (const std::string &param) const
	Deprecated method. More...
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...
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 Note: this is used by Actions creating transfers as well. 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...
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node)
	External method for calling moose error with added object context. More...

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

Static Public Attributes
static const libMesh::Number	OutOfMeshValue = -999999
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type. More...
static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name. More...
static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name. More...
static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp. More...
static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base. More...

Protected Types
enum	MeshDivisionTransferUse { RESTRICTION, MATCH_DIVISION_INDEX, MATCH_SUBAPP_INDEX }
	Matching enum for the mesh division behaviors. More...

Protected Member Functions
virtual void	checkSiblingsTransferSupported () const override
	Siblings transfers fully supported. More...
virtual void	prepareEvaluationOfInterpValues (const unsigned int var_index)=0
virtual void	evaluateInterpValues (const std::vector< std::pair< Point, unsigned int >> &incoming_points, std::vector< std::pair< Real, Real >> &outgoing_vals)=0
void	extractLocalFromBoundingBoxes (std::vector< BoundingBox > &local_bboxes)
bool	acceptPointInOriginMesh (unsigned int i_from, const std::vector< BoundingBox > &local_bboxes, const Point &pt, const unsigned int mesh_div, Real &distance) const
bool	inMesh (const libMesh::PointLocatorBase *const pl, const Point &pt) const
bool	inBlocks (const std::set< SubdomainID > &blocks, const Elem *elem) const
virtual bool	inBlocks (const std::set< SubdomainID > &blocks, const MooseMesh &mesh, const Elem *elem) const
bool	inBlocks (const std::set< SubdomainID > &blocks, const MooseMesh &mesh, const Node *node) const
bool	inBlocks (const std::set< SubdomainID > &blocks, const libMesh::PointLocatorBase *const pl, const Point &pt) const
bool	onBoundaries (const std::set< BoundaryID > &boundaries, const MooseMesh &mesh, const Node *node) const
bool	onBoundaries (const std::set< BoundaryID > &boundaries, const MooseMesh &mesh, const Elem *elem) const
bool	onBoundaries (const std::set< BoundaryID > &boundaries, const std::set< SubdomainID > &block_restriction, const MooseMesh &mesh, const libMesh::PointLocatorBase *const pl, const Point &pt) const
bool	acceptPointMeshDivision (const Point &pt, const unsigned int i_local, const unsigned int only_from_this_mesh_div) const
	Whether a point lies inside the mesh division delineated by the MeshDivision object. More...
bool	closestToPosition (unsigned int pos_index, const Point &pt) const
	Whether a point is closest to a position at the index specified than any other position. More...
bool	detectConflict (Real value_1, Real value_2, Real distance_1, Real distance_2) const
	Detects whether two source values are valid and equidistant for a desired target location. More...
void	registerConflict (unsigned int problem, dof_id_type dof_id, Point p, Real dist, bool local)
	Register a potential value conflict, e.g. 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...
void	checkParentAppUserObjectExecuteOn (const std::string &object_name) const
	Checks the execute_on flags for user object transfers with user objects on the source app which is also the parent app. More...
void	errorIfObjectExecutesOnTransferInSourceApp (const std::string &object_name) const
	Error if executing this MooseObject on EXEC_TRANSFER in a source multiapp (from_multiapp, e.g. 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	addUserObjectExecutionCheckParam (InputParameters &params)
	Add the execution order check parameter (to skip the warning if needed) More...
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
const std::vector< unsigned int >	_from_var_components
	Origin array/vector variable components. More...
const std::vector< unsigned int >	_to_var_components
	Target array/vector variable components. More...
const bool	_use_bounding_boxes
	Whether to use bounding boxes to determine the applications that may receive point requests then send value data, and at other various checks. More...
const bool	_use_nearest_app
	Whether to keep track of the distance from the requested point to the app position. More...
const Positions *	_nearest_positions_obj
bool	_source_app_must_contain_point
	Whether the source app mesh must actually contain the points for them to be considered or whether the bounding box is enough. More...
std::set< SubdomainID >	_from_blocks
	Origin block(s) restriction. More...
std::set< SubdomainID >	_to_blocks
	Target block(s) restriction. More...
std::set< BoundaryID >	_to_boundaries
	Target boundary(ies) restriction. More...
std::set< BoundaryID >	_from_boundaries
	Origin boundary(ies) restriction. More...
std::vector< const MeshDivision * >	_from_mesh_divisions
	Division of the origin mesh. More...
std::vector< const MeshDivision * >	_to_mesh_divisions
	Division of the target mesh. More...
const MooseEnum &	_from_mesh_division_behavior
	How to use the origin mesh divisions to restrict the transfer. More...
const MooseEnum &	_to_mesh_division_behavior
	How to use the target mesh divisions to restrict the transfer. More...
const bool	_elemental_boundary_restriction_on_sides
	Whether elemental variable boundary restriction is considered by element side or element nodes. More...
std::vector< std::unique_ptr< libMesh::PointLocatorBase > >	_from_point_locators
	Point locators, useful to examine point location with regards to domain restriction. More...
std::vector< unsigned int >	_global_app_start_per_proc
	First app each processor owns, indexed by processor If no app on the processor, will have a -1 for the app start instead. More...
bool	_greedy_search
	Whether or not a greedy strategy will be used If true, all the partitions will be checked for a given outgoing point. More...
bool	_search_value_conflicts
	Whether to look for conflicts between origin points, multiple valid values for a target point. More...
bool	_already_output_search_value_conflicts
	Whether we already output the search value conflicts. More...
const unsigned int	_search_value_conflicts_max_log
	How many conflicts are output to console. 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...
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...
Factory &	_factory
	The Factory associated with the MooseApp. More...
ActionFactory &	_action_factory
	Builds Actions. More...
const std::string &	_type
	The type of this class. More...
const std::string &	_name
	The name of this class. More...
const InputParameters &	_pars
	The object's parameters. More...
const Parallel::Communicator &	_communicator
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 Types
typedef std::unordered_map< processor_id_type, std::vector< std::pair< Point, unsigned int > > >	ProcessorToPointVec
	A map from pid to a set of points. More...
typedef std::unordered_map< processor_id_type, std::vector< PointInfo > >	ProcessorToPointInfoVec
	A map from pid to a set of point info. More...
typedef std::vector< std::unordered_map< dof_id_type, InterpInfo > >	DofobjectToInterpValVec
	A vector, indexed by to-problem id, of maps from dof object to interpolation values. More...
typedef PointIndexedMap	InterpCache
	A map from Point to interpolation values NOTE: this is not an asynchronous cache. More...
typedef std::vector< InterpCache >	InterpCaches
	A vector of such caches, indexed by to_problem. More...

Private Member Functions
void	prepareToTransfer ()
	Initialize supporting attributes like bounding boxes, processor app indexes etc. More...
void	transferVariable (unsigned int i)
	Performs the transfer for the variable of index i. More...
void	extractOutgoingPoints (const unsigned int var_index, ProcessorToPointVec &outgoing_points)
void	locatePointReceivers (const Point point, std::set< processor_id_type > &processors)
void	cacheIncomingInterpVals (processor_id_type pid, const unsigned int var_index, std::vector< PointInfo > &pointInfoVec, const std::vector< std::pair< Point, unsigned int >> &point_requests, const std::vector< std::pair< Real, Real >> &incoming_vals, DofobjectToInterpValVec &dofobject_to_valsvec, InterpCaches &interp_caches, InterpCaches &distance_caches)
void	examineReceivedValueConflicts (const unsigned int var_index, const DofobjectToInterpValVec &dofobject_to_valsvec, const InterpCaches &distance_caches)
	Remove potential value conflicts that did not materialize because another source was closer Several equidistant valid values were received, but they were not closest. More...
void	examineLocalValueConflicts (const unsigned int var_index, const DofobjectToInterpValVec &dofobject_to_valsvec, const InterpCaches &distance_caches)
	Remove potential value conflicts that did not materialize because another source was closer Several equidistant valid values were found when computing values to send, but they were not closest, another value got selected. More...
void	outputValueConflicts (const unsigned int var_index, const DofobjectToInterpValVec &dofobject_to_valsvec, const InterpCaches &distance_caches)
	Report on conflicts between overlapping child apps, equidistant origin points etc. More...
void	setSolutionVectorValues (const unsigned int var_index, const DofobjectToInterpValVec &dofobject_to_valsvec, const InterpCaches &interp_caches)
void	cacheOutgoingPointInfo (const Point point, const dof_id_type dof_object_id, const unsigned int problem_id, ProcessorToPointVec &outgoing_points)
Real	bboxMinDistance (const Point &p, const BoundingBox &bbox) const
	Compute minimum distance. More...
Real	bboxMaxDistance (const Point &p, const BoundingBox &bbox) const
	Compute max distance. More...
Point	getMaxToProblemsBBoxDimensions () const
	Obtains the max dimensions to scale all points in the mesh. More...
std::vector< BoundingBox >	getRestrictedFromBoundingBoxes () const
	Get from bounding boxes for given domains and boundaries. More...
std::vector< unsigned int >	getGlobalStartAppPerProc () const
	Get global index for the first app each processes owns Requires a global communication, must be called on every domain simultaneously. More...

Private Attributes
std::vector< MooseVariableFieldBase * >	_to_variables
	The target variables. More...
unsigned int	_var_size
	The number of variables to transfer. More...
bool	_error_on_miss
	Error out when some points can not be located. More...
const Real	_default_extrapolation_value
	Value to use when no received data is valid for a target location. More...
Real	_bbox_factor
	How much we should relax bounding boxes. More...
std::vector< Real >	_fixed_bbox_size
	Set the bounding box sizes manually. More...
std::vector< unsigned int >	_froms_per_proc
	Number of source/from applications per processor. This vector is indexed by processor id. More...
std::vector< BoundingBox >	_from_bboxes
	Bounding boxes for all source applications. More...
ProcessorToPointInfoVec	_processor_to_pointInfoVec
	A map from processor to pointInfo vector. More...
std::vector< std::tuple< unsigned int, dof_id_type, Point, Real > >	_local_conflicts
	Keeps track of all local equidistant points to requested points, creating an indetermination in which values should be sent for that request We keep the origin problem ID, the dof ID, the point, and the distance origin-target If using nearest-positions the origin problem ID is not set. More...
std::vector< std::tuple< unsigned int, dof_id_type, Point, Real > >	_received_conflicts
	Keeps track of all received conflicts. More...

Detailed Description

It is a general field transfer.

It will do the following things 1) From part of source domain to part of domain. Support subdomains/boundaries to subdomains/boundaries, mixing as appropriate 2) interpolation and extrapolation, as appropriate 3) Support higher order FEM 4) Support mixed orders between source and target variables 5) Support both distributed and replicated meshes 6) Support both origin and target displaced meshes 7) Support siblings transfers 8) Support multiple child apps in both the transfer source and target

Definition at line 37 of file MultiAppGeneralFieldTransfer.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.

DofobjectToInterpValVec

typedef std::vector<std::unordered_map<dof_id_type, InterpInfo> > MultiAppGeneralFieldTransfer::DofobjectToInterpValVec

private

A vector, indexed by to-problem id, of maps from dof object to interpolation values.

Definition at line 328 of file MultiAppGeneralFieldTransfer.h.

InterpCache

typedef PointIndexedMap MultiAppGeneralFieldTransfer::InterpCache

private

A map from Point to interpolation values NOTE: this is not an asynchronous cache.

It is built to completion during the transfer and used as a whole to reconstruct the target variable

Definition at line 333 of file MultiAppGeneralFieldTransfer.h.

InterpCaches

typedef std::vector<InterpCache> MultiAppGeneralFieldTransfer::InterpCaches

private

A vector of such caches, indexed by to_problem.

Definition at line 336 of file MultiAppGeneralFieldTransfer.h.

ProcessorToPointInfoVec

typedef std::unordered_map<processor_id_type, std::vector<PointInfo> > MultiAppGeneralFieldTransfer::ProcessorToPointInfoVec

private

A map from pid to a set of point info.

Definition at line 325 of file MultiAppGeneralFieldTransfer.h.

ProcessorToPointVec

typedef std::unordered_map<processor_id_type, std::vector<std::pair<Point, unsigned int> > > MultiAppGeneralFieldTransfer::ProcessorToPointVec

private

A map from pid to a set of points.

Definition at line 307 of file MultiAppGeneralFieldTransfer.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
  };

MeshDivisionTransferUse

enum MultiAppGeneralFieldTransfer::MeshDivisionTransferUse

protected

Matching enum for the mesh division behaviors.

Enumerator
RESTRICTION
MATCH_DIVISION_INDEX
MATCH_SUBAPP_INDEX

Definition at line 246 of file MultiAppGeneralFieldTransfer.h.

  {
    RESTRICTION,
    MATCH_DIVISION_INDEX,
    MATCH_SUBAPP_INDEX
  };

Constructor & Destructor Documentation

MultiAppGeneralFieldTransfer()

MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer

(

const InputParameters &

parameters

)

Definition at line 159 of file MultiAppGeneralFieldTransfer.C.

  : MultiAppConservativeTransfer(parameters),
    _from_var_components(getParam<std::vector<unsigned int>>("source_variable_components")),
    _to_var_components(getParam<std::vector<unsigned int>>("target_variable_components")),
    _use_bounding_boxes(getParam<bool>("use_bounding_boxes")),
    _use_nearest_app(getParam<bool>("use_nearest_app")),
    _nearest_positions_obj(
        isParamValid("use_nearest_position")
            ? &_fe_problem.getPositionsObject(getParam<PositionsName>("use_nearest_position"))
            : nullptr),
    _source_app_must_contain_point(getParam<bool>("from_app_must_contain_point")),
    _from_mesh_division_behavior(getParam<MooseEnum>("from_mesh_division_usage")),
    _to_mesh_division_behavior(getParam<MooseEnum>("to_mesh_division_usage")),
    _elemental_boundary_restriction_on_sides(
        getParam<MooseEnum>("elemental_boundary_restriction") == "sides"),
    _greedy_search(getParam<bool>("greedy_search")),
    _search_value_conflicts(getParam<bool>("search_value_conflicts")),
    _already_output_search_value_conflicts(false),
    _search_value_conflicts_max_log(getParam<unsigned int>("value_conflicts_output")),
    _error_on_miss(getParam<bool>("error_on_miss")),
    _default_extrapolation_value(getParam<Real>("extrapolation_constant")),
    _bbox_factor(getParam<Real>("bbox_factor")),
    _fixed_bbox_size(isParamValid("fixed_bounding_box_size")
                         ? getParam<std::vector<Real>>("fixed_bounding_box_size")
                         : std::vector<Real>(3, 0))
{
  _var_size = _to_var_names.size();
  if (_to_var_names.size() != _from_var_names.size() && !parameters.isPrivate("source_variable"))
    paramError("variable", "The number of variables to transfer to and from should be equal");

  // Check the parameters of the components of the array / vector variable
  if (_from_var_names.size() != _from_var_components.size() && _from_var_components.size() > 0)
    paramError("source_variable_components",
               "This parameter must be equal to the number of source variables");
  if (_to_var_names.size() != _to_var_components.size() && _to_var_components.size() > 0)
    paramError("target_variable_components",
               "This parameter must be equal to the number of target variables");

  // Make simple 'use_nearest_app' parameter rely on Positions
  if (_use_nearest_app)
  {
    if (_nearest_positions_obj)
      paramError("use_nearest_app", "Cannot use nearest-app and nearest-position together");
    if (!hasFromMultiApp())
      paramError("use_nearest_app",
                 "Should have a 'from_multiapp' when using the nearest-app informed search");
    auto pos_params = _app.getFactory().getValidParams("MultiAppPositions");
    pos_params.set<std::vector<MultiAppName>>("multiapps") = {getFromMultiApp()->name()};
    _fe_problem.addReporter("MultiAppPositions", "_created_for_" + name(), pos_params);
    _nearest_positions_obj = &_fe_problem.getPositionsObject("_created_for_" + name());
  }

  // Dont let users get wrecked by bounding boxes if it looks like they are trying to extrapolate
  if (!_source_app_must_contain_point && _use_bounding_boxes &&
      (_nearest_positions_obj || isParamSetByUser("from_app_must_contain_point")))
    if (!isParamSetByUser("bbox_factor") && !isParamSetByUser("fixed_bounding_box_size"))
      mooseWarning(
          "Extrapolation (nearest-source options, outside-app source) parameters have "
          "been passed, but no subapp bounding box expansion parameters have been passed.");

  if (!_use_bounding_boxes &&
      (isParamValid("fixed_bounding_box_size") || isParamSetByUser("bbox_factor")))
    paramError("use_bounding_boxes",
               "Cannot pass additional bounding box parameters (sizes, expansion, etc) if we are "
               "not using bounding boxes");
}

Member Function Documentation

acceptPointInOriginMesh()

bool MultiAppGeneralFieldTransfer::acceptPointInOriginMesh ( unsigned int  i_from, const std::vector< BoundingBox > &  local_bboxes, const Point &  pt, const unsigned int  mesh_div, Real &  distance  ) const

protected

Definition at line 1551 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), and MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects().

{
  if (_use_bounding_boxes && !local_bboxes[i_from].contains_point(pt))
    return false;
  else
  {
    auto * pl = _from_point_locators[i_from].get();
    const auto from_global_num = getGlobalSourceAppIndex(i_from);
    const auto transformed_pt = _from_transforms[from_global_num]->mapBack(pt);

    // Check point against source block restriction
    if (!_from_blocks.empty() && !inBlocks(_from_blocks, pl, transformed_pt))
      return false;

    // Check point against source boundary restriction. Block restriction will speed up the search
    if (!_from_boundaries.empty() &&
        !onBoundaries(_from_boundaries, _from_blocks, *_from_meshes[i_from], pl, transformed_pt))
      return false;

    // Check point against the source mesh division
    if ((!_from_mesh_divisions.empty() || !_to_mesh_divisions.empty()) &&
        !acceptPointMeshDivision(transformed_pt, i_from, only_from_mesh_div))
      return false;

    // Get nearest position (often a subapp position) for the target point
    // We want values from the child app that is closest to the same position as the target
    Point nearest_position_source;
    if (_nearest_positions_obj)
    {
      const bool initial = _fe_problem.getCurrentExecuteOnFlag() == EXEC_INITIAL;
      // The search for the nearest position is done in the reference frame
      const Point nearest_position = _nearest_positions_obj->getNearestPosition(pt, initial);
      nearest_position_source = _nearest_positions_obj->getNearestPosition(
          (*_from_transforms[from_global_num])(Point(0, 0, 0)), initial);

      if (!_skip_coordinate_collapsing &&
          _from_transforms[from_global_num]->hasNonTranslationTransformation())
        mooseError("Rotation and scaling currently unsupported with nearest positions transfer.");

      // Compute distance to nearest position and nearest position source
      const Real distance_to_position_nearest_source = (pt - nearest_position_source).norm();
      const Real distance_to_nearest_position = (pt - nearest_position).norm();

      // Source (usually app position) is not closest to the same positions as the target, dont
      // send values. We check the distance instead of the positions because if they are the same
      // that means there's two equidistant positions and we would want to capture that as a "value
      // conflict"
      if (!MooseUtils::absoluteFuzzyEqual(distance_to_position_nearest_source,
                                          distance_to_nearest_position))
        return false;

      // Set the distance as the distance from the nearest position to the target point
      distance = distance_to_position_nearest_source;
    }

    // Check that the app actually contains the origin point
    // We dont need to check if we already found it in a block or a boundary
    if (_from_blocks.empty() && _from_boundaries.empty() && _source_app_must_contain_point &&
        !inMesh(pl, transformed_pt))
      return false;
  }
  return true;
}

acceptPointMeshDivision()

bool MultiAppGeneralFieldTransfer::acceptPointMeshDivision ( const Point &  pt, const unsigned int  i_local, const unsigned int  only_from_this_mesh_div  ) const

protected

Whether a point lies inside the mesh division delineated by the MeshDivision object.

Parameters

pt	point to examine, in the local coordinates (source frame for from_direction=true)
i_local	the index of the problem to consider, holding the mesh division to examine
only_from_this_mesh_div	a mesh division index that must be matched when the to/from_mesh_division_behavior for the direction examined is MATCH_DIVISION/SUBAPP_INDEX It is ignored otherwise

Definition at line 1738 of file MultiAppGeneralFieldTransfer.C.

Referenced by acceptPointInOriginMesh().

{
  // This routine can also be called to examine if the to_mesh_division index matches the current
  // source subapp index
  unsigned int source_mesh_div = MooseMeshDivision::INVALID_DIVISION_INDEX - 1;
  if (!_from_mesh_divisions.empty())
    source_mesh_div = _from_mesh_divisions[i_local]->divisionIndex(pt);

  // If the point is not indexed in the source division
  if (!_from_mesh_divisions.empty() && source_mesh_div == MooseMeshDivision::INVALID_DIVISION_INDEX)
    return false;
  // If the point is not the at the same index in the target and the origin meshes, reject
  else if ((_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX ||
            _to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX) &&
           source_mesh_div != only_from_this_mesh_div)
    return false;
  // If the point is at a certain division index that is not the same as the index of the subapp
  // we wanted the information to be from for that point, reject
  else if (_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX &&
           source_mesh_div != only_from_this_mesh_div)
    return false;
  else if (_to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX &&
           only_from_this_mesh_div != getGlobalSourceAppIndex(i_local))
    return false;
  else
    return true;
}

addBBoxFactorParam()

void MultiAppTransfer::addBBoxFactorParam ( InputParameters &  params )

staticprotectedinherited

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

Definition at line 59 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 Note: this is used by Actions creating transfers as well.

Definition at line 73 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");
}

addUserObjectExecutionCheckParam()

void MultiAppTransfer::addUserObjectExecutionCheckParam ( InputParameters &  params )

staticprotectedinherited

Add the execution order check parameter (to skip the warning if needed)

Definition at line 86 of file MultiAppTransfer.C.

Referenced by MultiAppPostprocessorToAuxScalarTransfer::validParams(), MultiAppVectorPostprocessorTransfer::validParams(), MultiAppPostprocessorTransfer::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), and MultiAppUserObjectTransfer::validParams().

{
  params.addParam<bool>("warn_source_object_execution_schedule",
                        true,
                        "Emit a warning when the transfer execution schedule is detected to lag "
                        "information from the user object. Note that the check cannot detect all "
                        "potential wrong combinations of user-object/transfer execution schedules");
}

bboxMaxDistance()

Real MultiAppGeneralFieldTransfer::bboxMaxDistance ( const Point &  p, const BoundingBox &  bbox  ) const

private

Compute max distance.

Parameters

p	the point of interest
bbox	the bounding box to find the maximum distance from

Definition at line 1806 of file MultiAppGeneralFieldTransfer.C.

Referenced by locatePointReceivers().

{
  std::array<Point, 2> source_points = {{bbox.first, bbox.second}};

  std::array<Point, 8> all_points;
  for (unsigned int x = 0; x < 2; x++)
    for (unsigned int y = 0; y < 2; y++)
      for (unsigned int z = 0; z < 2; z++)
        all_points[x + 2 * y + 4 * z] =
            Point(source_points[x](0), source_points[y](1), source_points[z](2));

  Real max_distance = 0.;

  for (unsigned int i = 0; i < 8; i++)
  {
    Real distance = (p - all_points[i]).norm();
    if (distance > max_distance)
      max_distance = distance;
  }

  return max_distance;
}

bboxMinDistance()

Real MultiAppGeneralFieldTransfer::bboxMinDistance ( const Point &  p, const BoundingBox &  bbox  ) const

private

Compute minimum distance.

Parameters

p	the point of interest
bbox	the bounding box to find the minimum distance from

Definition at line 1830 of file MultiAppGeneralFieldTransfer.C.

Referenced by locatePointReceivers().

{
  std::array<Point, 2> source_points = {{bbox.first, bbox.second}};

  std::array<Point, 8> all_points;
  for (unsigned int x = 0; x < 2; x++)
    for (unsigned int y = 0; y < 2; y++)
      for (unsigned int z = 0; z < 2; z++)
        all_points[x + 2 * y + 4 * z] =
            Point(source_points[x](0), source_points[y](1), source_points[z](2));

  Real min_distance = std::numeric_limits<Real>::max();

  for (unsigned int i = 0; i < 8; i++)
  {
    Real distance = (p - all_points[i]).norm();
    if (distance < min_distance)
      min_distance = distance;
  }

  return min_distance;
}

cacheIncomingInterpVals()

void MultiAppGeneralFieldTransfer::cacheIncomingInterpVals ( processor_id_type  pid, const unsigned int  var_index, std::vector< PointInfo > &  pointInfoVec, const std::vector< std::pair< Point, unsigned int >> &  point_requests, const std::vector< std::pair< Real, Real >> &  incoming_vals, DofobjectToInterpValVec &  dofobject_to_valsvec, InterpCaches &  interp_caches, InterpCaches &  distance_caches  )

private

Definition at line 906 of file MultiAppGeneralFieldTransfer.C.

Referenced by transferVariable().

{
  mooseAssert(pointInfoVec.size() == incoming_vals.size(),
              "Number of dof objects does not equal to the number of incoming values");

  dof_id_type val_offset = 0;
  for (const auto & pointinfo : pointInfoVec)
  {
    // Retrieve target information from cached point infos
    const auto problem_id = pointinfo.problem_id;
    const auto dof_object_id = pointinfo.dof_object_id;

    auto & fe_type = _to_variables[var_index]->feType();
    bool is_nodal = _to_variables[var_index]->isNodal();

    // In the higher order elemental variable case, we receive point values, not nodal or
    // elemental. We use an InterpCache to store the values. The distance_cache is necessary to
    // choose between multiple origin problems sending values. This code could be unified with the
    // lower order order case by using the dofobject_to_valsvec
    if (fe_type.order > CONSTANT && !is_nodal)
    {
      // Cache solution on target mesh in its local frame of reference
      InterpCache & value_cache = interp_caches[problem_id];
      InterpCache & distance_cache = distance_caches[problem_id];
      Point p = _to_transforms[getGlobalTargetAppIndex(problem_id)]->mapBack(
          point_requests[val_offset].first);
      const Number val = incoming_vals[val_offset].first;

      // Initialize distance to be able to compare
      if (!distance_cache.hasKey(p))
        distance_cache[p] = std::numeric_limits<Real>::max();

      // We should only have one closest value for each variable at any given point.
      // While there are shared Qps, on vertices for higher order variables usually,
      // the generic projector only queries each point once
      if (_search_value_conflicts && !GeneralFieldTransfer::isBetterOutOfMeshValue(val) &&
          value_cache.hasKey(p) != 0 && !MooseUtils::absoluteFuzzyEqual(value_cache[p], val) &&
          MooseUtils::absoluteFuzzyEqual(distance_cache[p], incoming_vals[val_offset].second))
        registerConflict(problem_id, dof_object_id, p, incoming_vals[val_offset].second, false);

      // if we use the nearest app, even if the value is bad we want to save the distance because
      // it's the distance to the app, if that's the closest app then so be it with the bad value
      if ((!GeneralFieldTransfer::isBetterOutOfMeshValue(val) || _use_nearest_app) &&
          MooseUtils::absoluteFuzzyGreaterThan(distance_cache[p], incoming_vals[val_offset].second))
      {
        // NOTE: We store the distance as well as the value. We really only need the
        // value to construct the variable, but the distance is used to make decisions in nearest
        // node schemes on which value to use
        value_cache[p] = val;
        distance_cache[p] = incoming_vals[val_offset].second;
      }
    }
    else
    {
      // Using the dof object pointer, so we can handle
      // both element and node using the same code
#ifndef NDEBUG
      auto var_num = _to_variables[var_index]->number();
      auto & to_sys = _to_variables[var_index]->sys();

      const MeshBase & to_mesh = _to_problems[problem_id]->mesh(_displaced_target_mesh).getMesh();
      const DofObject * dof_object_ptr = nullptr;
      const auto sys_num = to_sys.number();
      // It is a node
      if (is_nodal)
        dof_object_ptr = to_mesh.node_ptr(dof_object_id);
      // It is an element
      else
        dof_object_ptr = to_mesh.elem_ptr(dof_object_id);

      // We should only be supporting nodal and constant elemental
      // variables in this code path; if we see multiple DoFs on one
      // object we should have been using GenericProjector
      mooseAssert(dof_object_ptr->n_dofs(sys_num, var_num) == 1,
                  "Unexpectedly found " << dof_object_ptr->n_dofs(sys_num, var_num)
                                        << "dofs instead of 1");
#endif

      auto & dofobject_to_val = dofobject_to_valsvec[problem_id];

      // Check if we visited this dof object earlier
      auto values_ptr = dofobject_to_val.find(dof_object_id);
      // We did not visit this
      if (values_ptr == dofobject_to_val.end())
      {
        // Values for this dof object
        auto & val = dofobject_to_val[dof_object_id];
        // Interpolation value
        val.interp = incoming_vals[val_offset].first;
        // Where this value came from
        val.pid = pid;
        // Distance
        val.distance = incoming_vals[val_offset].second;
      }
      else
      {
        auto & val = values_ptr->second;

        // Look for value conflicts
        if (detectConflict(val.interp,
                           incoming_vals[val_offset].first,
                           val.distance,
                           incoming_vals[val_offset].second))
        {
          // Keep track of distance and value
          const Point p =
              getPointInTargetAppFrame(point_requests[val_offset].first,
                                       problem_id,
                                       "Registration of received equi-distant value conflict");
          registerConflict(problem_id, dof_object_id, p, incoming_vals[val_offset].second, false);
        }

        // We adopt values that are, in order of priority
        // - valid (or from nearest app)
        // - closest distance
        // - the smallest rank with the same distance
        // It is debatable whether we want invalid values from the nearest app. It could just be
        // that the app position was closer but the extent of another child app was large enough
        if ((!GeneralFieldTransfer::isBetterOutOfMeshValue(incoming_vals[val_offset].first) ||
             _use_nearest_app) &&
            (MooseUtils::absoluteFuzzyGreaterThan(val.distance, incoming_vals[val_offset].second) ||
             ((val.pid > pid) &&
              MooseUtils::absoluteFuzzyEqual(val.distance, incoming_vals[val_offset].second))))
        {
          val.interp = incoming_vals[val_offset].first;
          val.pid = pid;
          val.distance = incoming_vals[val_offset].second;
        }
      }
    }

    // Move it to next position
    val_offset++;
  }
}

cacheOutgoingPointInfo()

void MultiAppGeneralFieldTransfer::cacheOutgoingPointInfo ( const Point  point, const dof_id_type  dof_object_id, const unsigned int  problem_id, ProcessorToPointVec &  outgoing_points  )

private

Definition at line 707 of file MultiAppGeneralFieldTransfer.C.

Referenced by extractOutgoingPoints().

{
  std::set<processor_id_type> processors;
  // Find which processors will receive point data so they can send back value data
  // The list can be larger than needed, depending on the heuristic / algorithm used to make
  // the call on whether a processor (and the apps it runs) should be involved
  processors.clear();
  locatePointReceivers(point, processors);

  // We need to send this location data to these processors so they can send back values
  for (const auto pid : processors)
  {
    // Select which from_mesh_division the source data must come from for this point
    unsigned int required_source_division = 0;
    if (_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX)
      required_source_division = getGlobalTargetAppIndex(problem_id);
    else if (_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX ||
             _to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX ||
             _to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX)
      required_source_division = _to_mesh_divisions[problem_id]->divisionIndex(
          _to_transforms[getGlobalTargetAppIndex(problem_id)]->mapBack(point));

    // Skip if we already know we don't want the point
    if (required_source_division == MooseMeshDivision::INVALID_DIVISION_INDEX)
      continue;

    // Store outgoing information for every source process
    outgoing_points[pid].push_back(std::pair<Point, unsigned int>(point, required_source_division));

    // Store point information locally for processing received data
    // We can use these information when inserting values into the solution vector
    PointInfo pointinfo;
    pointinfo.problem_id = problem_id;
    pointinfo.dof_object_id = dof_object_id;
    _processor_to_pointInfoVec[pid].push_back(pointinfo);
  }
}

callMooseError() [1/2]

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

inherited

External method for calling moose error with added object context.

Parameters

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

Definition at line 102 of file MooseBase.C.

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

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

callMooseError() [2/2]

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

staticinherited

External method for calling moose error with added object context.

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

Parameters

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

Definition at line 110 of file MooseBase.C.

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

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

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

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

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 173 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"));
}

checkParentAppUserObjectExecuteOn()

void MultiAppTransfer::checkParentAppUserObjectExecuteOn ( const std::string &  object_name ) const

protectedinherited

Checks the execute_on flags for user object transfers with user objects on the source app which is also the parent app.

This is to prevent a common mistake lagging the data from the user object

Definition at line 672 of file MultiAppTransfer.C.

Referenced by MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppUserObjectTransfer::execute(), and MultiAppVectorPostprocessorTransfer::executeToMultiapp().

{
  // Source app is not the parent, most execution schedules are fine since the transfer occurs after
  // the app has run NOTE: not true for siblings transfer
  if (hasFromMultiApp())
    return;
  // Get user object from parent. We don't know the type
  const auto & uo = _fe_problem.getUserObject<UserObject>(object_name);
  // If we are executing on transfers, every additional schedule is not a problem
  if (uo.getExecuteOnEnum().contains(EXEC_TRANSFER))
    return;
  // If we are transferring on the same schedule as we are executing, we are lagging. Is it on
  // purpose? We don't know, so we will give a warning unless silenced.
  // The derived-classes offer the parameter to silence this warning
  // Note: UOs execute before transfers on INITIAL so it's not a problem at this time
  if (uo.getExecuteOnEnum().contains(_fe_problem.getCurrentExecuteOnFlag()) &&
      _fe_problem.getCurrentExecuteOnFlag() != EXEC_INITIAL)
    if (!isParamValid("warn_source_object_execution_schedule") ||
        getParam<bool>("warn_source_object_execution_schedule"))
      uo.paramWarning("execute_on",
                      "This UserObject-derived class is being executed on '" +
                          Moose::stringify(_fe_problem.getCurrentExecuteOnFlag()) +
                          "' and also providing values for the '" + name() +
                          "' transfer, on that same execution schedule. Because user objects are "
                          "executed after transfers are, this means the values provided by this "
                          "user object are lagged. If you are ok with this, then set the "
                          "'warn_source_object_execution_schedule' parameter to false in this "
                          "Transfer. If not, then execute '" +
                          uo.name() +
                          "' on TRANSFER by adding it to the 'execute_on' vector parameter.");
}

checkSiblingsTransferSupported()

virtual void MultiAppGeneralFieldTransfer::checkSiblingsTransferSupported ( ) const

inlineoverrideprotectedvirtual

Siblings transfers fully supported.

Reimplemented from MultiAppTransfer.

Definition at line 57 of file MultiAppGeneralFieldTransfer.h.

{}

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 613 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.");
  }
}

closestToPosition()

bool MultiAppGeneralFieldTransfer::closestToPosition ( unsigned int  pos_index, const Point &  pt  ) const

protected

Whether a point is closest to a position at the index specified than any other position.

Parameters

pos_index	the index of the position to consider in the positions vector
pt	the point

Returns

whether the point is closest to this position than any other in the positions vector

Definition at line 1768 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), and MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource().

{
  mooseAssert(_nearest_positions_obj, "Should not be here without a positions object");
  if (!_skip_coordinate_collapsing)
    paramError("skip_coordinate_collapsing", "Coordinate collapsing not implemented");
  bool initial = _fe_problem.getCurrentExecuteOnFlag() == EXEC_INITIAL;
  if (!_search_value_conflicts)
    // Faster to just compare the index
    return pos_index == _nearest_positions_obj->getNearestPositionIndex(pt, initial);
  else
  {
    // Get the distance to the position and see if we are missing a value just because the position
    // is not officially the closest, but it is actually at the same distance
    const auto nearest_position = _nearest_positions_obj->getNearestPosition(pt, initial);
    const auto nearest_position_at_index = _nearest_positions_obj->getPosition(pos_index, initial);
    Real distance_to_position_at_index = (pt - nearest_position_at_index).norm();
    const Real distance_to_nearest_position = (pt - nearest_position).norm();

    if (!MooseUtils::absoluteFuzzyEqual(distance_to_position_at_index,
                                        distance_to_nearest_position))
      return false;
    // Actually the same position (point)
    else if (nearest_position == nearest_position_at_index)
      return true;
    else
    {
      mooseWarning("Two equidistant positions ",
                   nearest_position,
                   " and ",
                   nearest_position_at_index,
                   " detected near point ",
                   pt);
      return true;
    }
  }
}

connectControllableParams()

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

inherited

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

Parameters

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

Definition at line 74 of file MooseBase.C.

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

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

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

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

detectConflict()

bool MultiAppGeneralFieldTransfer::detectConflict ( Real  value_1, Real  value_2, Real  distance_1, Real  distance_2  ) const

protected

Detects whether two source values are valid and equidistant for a desired target location.

Parameters

value_1	value from the first value source / subapp
value_2	value from the second value source / subapp
distance_1	distance from the first source
distance_2	distance from the second source

Returns

true if the values are different and distances from the source points/apps are the same

Definition at line 1986 of file MultiAppGeneralFieldTransfer.C.

Referenced by cacheIncomingInterpVals(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), and MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects().

{
  // No conflict if we're not looking for them
  if (_search_value_conflicts)
    // Only consider conflicts if the values are valid and different
    if (current_value != GeneralFieldTransfer::BetterOutOfMeshValue &&
        new_value != GeneralFieldTransfer::BetterOutOfMeshValue &&
        !MooseUtils::absoluteFuzzyEqual(current_value, new_value))
      // Conflict only occurs if the origin points are equidistant
      if (MooseUtils::absoluteFuzzyEqual(current_distance, new_distance))
        return true;
  return false;
}

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 39 of file MooseObject.h.

Referenced by EigenKernel::enabled().

{ return _enabled; }

errorIfObjectExecutesOnTransferInSourceApp()

void MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp ( const std::string &  object_name ) const

protectedinherited

Error if executing this MooseObject on EXEC_TRANSFER in a source multiapp (from_multiapp, e.g.

child/sibling app). Note that, conversely, when the parent app is the source application, it is usually desired to use EXEC_TRANSFER for a MooseObject that provides the values to transfer.

Parameters

object_name

name of the object to check the execute_on flags for

Definition at line 705 of file MultiAppTransfer.C.

Referenced by MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppUserObjectTransfer::execute(), and MultiAppVectorPostprocessorTransfer::executeFromMultiapp().

{
  // parent app is the source app, EXEC_TRANSFER is fine
  if (!hasFromMultiApp())
    return;
  // Get the app and problem
  const auto & app = getFromMultiApp();
  if (!app->hasApp())
    return;
  const auto & problem = app->appProblemBase(app->firstLocalApp());
  // Use the warehouse to find the object
  std::vector<SetupInterface *> objects_with_exec_on;
  problem.theWarehouse()
      .query()
      .template condition<AttribName>(object_name)
      .template condition<AttribExecOns>(EXEC_TRANSFER)
      .queryInto(objects_with_exec_on);
  if (objects_with_exec_on.size())
    mooseError("Object '" + object_name +
               "' should not be executed on EXEC_TRANSFER, because this transfer has "
               "indicated it does not support it.\nExecuting this object on TIMESTEP_END should be "
               "sufficient to get updated values.");
}

errorPrefix()

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

inlineinherited

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

Definition at line 260 of file MooseBase.h.

{ return messagePrefix(); }

evaluateInterpValues()

virtual void MultiAppGeneralFieldTransfer::evaluateInterpValues ( const std::vector< std::pair< Point, unsigned int >> &  incoming_points, std::vector< std::pair< Real, Real >> &  outgoing_vals  )

protectedpure virtual

Implemented in MultiAppGeneralFieldNearestLocationTransfer, MultiAppGeneralFieldUserObjectTransfer, and MultiAppGeneralFieldShapeEvaluationTransfer.

Referenced by transferVariable().

examineLocalValueConflicts()

void MultiAppGeneralFieldTransfer::examineLocalValueConflicts ( const unsigned int  var_index, const DofobjectToInterpValVec &  dofobject_to_valsvec, const InterpCaches &  distance_caches  )

private

Remove potential value conflicts that did not materialize because another source was closer Several equidistant valid values were found when computing values to send, but they were not closest, another value got selected.

Parameters

var_index	the index of the variable of interest
dofobject_to_valsvec	a data structure mapping dofobjects to received values and distances (used for nodal-value-dof-only variables and constant monomials)
distance_caches	a cache holding the distances received (used for higher order elemental variables)

Definition at line 1115 of file MultiAppGeneralFieldTransfer.C.

Referenced by outputValueConflicts().

{
  const auto var_name = getToVarName(var_index);
  // We must check a posteriori because we could have:
  // - two equidistant points with different values from two different problems
  // - two (or more) equidistant points with different values from the same problem
  // but a third point/value couple from another problem is actually closer, so there is no
  // conflict because only that last one matters. We check here whether the potential conflicts
  // actually were the nearest points. We use several global reductions. If there are not too many
  // potential conflicts (and there should not be in a well-posed problem) it should be manageably
  // expensive

  // Move relevant conflict info (location, distance) to a smaller data structure
  std::vector<std::tuple<Point, Real>> potential_conflicts;
  potential_conflicts.reserve(_local_conflicts.size());

  // Loop over potential conflicts to broadcast all the conflicts
  for (auto conflict_it = _local_conflicts.begin(); conflict_it != _local_conflicts.end();
       ++conflict_it)
  {
    // Extract info for the potential conflict
    const auto potential_conflict = *conflict_it;
    const unsigned int i_from = std::get<0>(potential_conflict);
    Point p = std::get<2>(potential_conflict);
    const Real distance = std::get<3>(potential_conflict);
    // If not using nearest-positions: potential conflict was saved in the source frame
    // If using nearest-positions: potential conflict was saved in the reference frame
    if (!_nearest_positions_obj)
    {
      const auto from_global_num = getGlobalSourceAppIndex(i_from);
      p = (*_from_transforms[from_global_num])(p);
    }

    // Send data in the global frame of reference
    potential_conflicts.push_back(std::make_tuple(p, distance));
  }
  _communicator.allgather(potential_conflicts, false);
  // conflicts could have been reported multiple times within a tolerance
  std::sort(potential_conflicts.begin(), potential_conflicts.end());
  potential_conflicts.erase(unique(potential_conflicts.begin(),
                                   potential_conflicts.end(),
                                   [](auto l, auto r)
                                   {
                                     return std::get<0>(l).absolute_fuzzy_equals(std::get<0>(r)) &&
                                            std::abs(std::get<1>(l) - std::get<1>(r)) < TOLERANCE;
                                   }),
                            potential_conflicts.end());

  std::vector<std::tuple<Point, Real>> real_conflicts;
  real_conflicts.reserve(potential_conflicts.size());

  // For each potential conflict, we need to identify what problem asked for that value
  for (auto conflict_it = potential_conflicts.begin(); conflict_it != potential_conflicts.end();
       ++conflict_it)
  {
    // Extract info for the potential conflict
    auto potential_conflict = *conflict_it;
    const Point p = std::get<0>(potential_conflict);
    const Real distance = std::get<1>(potential_conflict);

    // Check all the problems to try to find this requested point in the data structures filled
    // with the received information
    bool target_found = false;
    bool conflict_real = false;
    for (const auto i_to : index_range(_to_problems))
    {
      // Extract variable info
      auto & es = getEquationSystem(*_to_problems[i_to], _displaced_target_mesh);
      System * to_sys = find_sys(es, var_name);
      auto var_num = to_sys->variable_number(var_name);
      auto & fe_type = to_sys->variable_type(var_num);
      bool is_nodal = _to_variables[var_index]->isNodal();

      // Move to the local frame of reference for the target problem
      Point local_p =
          getPointInTargetAppFrame(p, i_to, "Resolution of local value conflicts detected");

      // Higher order elemental
      if (fe_type.order > CONSTANT && !is_nodal)
      {
        // distance_caches finds use a binned floating point search
        auto cached_distance = distance_caches[i_to].find(local_p);
        if (cached_distance != distance_caches[i_to].end())
        {
          target_found = true;
          // Distance between source & target is still the distance we found in the sending
          // process when we detected a potential overlap while gathering values to send
          if (MooseUtils::absoluteFuzzyEqual(cached_distance->second, distance))
            conflict_real = true;
        }
      }
      // Nodal-value-dof-only and const monomial variable
      else
      {
        // Find the dof id for the variable to be set
        dof_id_type dof_object_id = std::numeric_limits<dof_id_type>::max();
        auto pl = _to_problems[i_to]->mesh().getPointLocator();
        pl->enable_out_of_mesh_mode();
        if (is_nodal)
        {
          auto node = pl->locate_node(local_p);
          if (node)
            // this is not the dof_id for the variable, but the dof_object_id
            dof_object_id = node->id();
        }
        else
        {
          auto elem = (*pl)(local_p);
          if (elem)
            dof_object_id = elem->id();
        }
        pl->disable_out_of_mesh_mode();

        // point isn't even in mesh
        if (dof_object_id == std::numeric_limits<dof_id_type>::max())
          continue;

        // this dof was not requested by this problem on this process
        if (dofobject_to_valsvec[i_to].find(dof_object_id) == dofobject_to_valsvec[i_to].end())
          continue;

        target_found = true;
        // Check the saved distance in the vector of saved results. If the same, then the local
        // conflict we detected with that distance is still an issue after receiving all values
        if (MooseUtils::absoluteFuzzyEqual(
                dofobject_to_valsvec[i_to].find(dof_object_id)->second.distance, distance))
          conflict_real = true;
      }
    }
    // Only keep the actual conflicts / overlaps
    if (target_found && conflict_real)
      real_conflicts.push_back(potential_conflict);
  }

  // Communicate real conflicts to all so they can be checked by every process
  _communicator.allgather(real_conflicts, false);

  // Delete potential conflicts that were resolved
  // Each local list of conflicts will now be updated. It's important to keep conflict lists local
  // so we can give more context like the sending processor id (the domain of which can be
  // inspected by the user)
  for (auto conflict_it = _local_conflicts.begin(); conflict_it != _local_conflicts.end();)
  {
    // Extract info for the potential conflict
    const auto potential_conflict = *conflict_it;
    const unsigned int i_from = std::get<0>(potential_conflict);
    Point p = std::get<2>(potential_conflict);
    const Real distance = std::get<3>(potential_conflict);
    if (!_nearest_positions_obj)
    {
      const auto from_global_num = getGlobalSourceAppIndex(i_from);
      p = (*_from_transforms[from_global_num])(p);
    }

    // If not in the vector of real conflicts, was not real so delete it
    if (std::find_if(real_conflicts.begin(),
                     real_conflicts.end(),
                     [p, distance](const auto & item)
                     {
                       return std::get<0>(item).absolute_fuzzy_equals(p) &&
                              std::abs(std::get<1>(item) - distance) < TOLERANCE;
                     }) == real_conflicts.end())
      _local_conflicts.erase(conflict_it);
    else
      ++conflict_it;
  }
}

examineReceivedValueConflicts()

void MultiAppGeneralFieldTransfer::examineReceivedValueConflicts ( const unsigned int  var_index, const DofobjectToInterpValVec &  dofobject_to_valsvec, const InterpCaches &  distance_caches  )

private

Remove potential value conflicts that did not materialize because another source was closer Several equidistant valid values were received, but they were not closest.

Parameters

var_index	the index of the variable of interest
dofobject_to_valsvec	a data structure mapping dofobjects to received values and distances (used for nodal-value-dof-only variables and constant monomials)
distance_caches	a cache holding the distances received (used for higher order elemental variables)

Definition at line 1062 of file MultiAppGeneralFieldTransfer.C.

Referenced by outputValueConflicts().

{
  const auto var_name = getToVarName(var_index);
  // We must check a posteriori because we could have two
  // equidistant points with different values from two different problems, but a third point from
  // another problem is actually closer, so there is no conflict because only that last one
  // matters We check here whether the potential conflicts actually were the nearest points Loop
  // over potential conflicts
  for (auto conflict_it = _received_conflicts.begin(); conflict_it != _received_conflicts.end();)
  {
    const auto potential_conflict = *conflict_it;
    bool overlap_found = false;

    // Extract info for the potential conflict
    const unsigned int problem_id = std::get<0>(potential_conflict);
    const dof_id_type dof_object_id = std::get<1>(potential_conflict);
    const Point p = std::get<2>(potential_conflict);
    const Real distance = std::get<3>(potential_conflict);

    // Extract target variable info
    auto & es = getEquationSystem(*_to_problems[problem_id], _displaced_target_mesh);
    System * to_sys = find_sys(es, var_name);
    auto var_num = to_sys->variable_number(var_name);
    auto & fe_type = to_sys->variable_type(var_num);
    bool is_nodal = _to_variables[var_index]->isNodal();

    // Higher order elemental
    if (fe_type.order > CONSTANT && !is_nodal)
    {
      auto cached_distance = distance_caches[problem_id].find(p);
      if (cached_distance == distance_caches[problem_id].end())
        mooseError("Conflict point was not found in the map of all origin-target distances");
      // Distance is still the distance when we detected a potential overlap
      if (MooseUtils::absoluteFuzzyEqual(cached_distance->second, distance))
        overlap_found = true;
    }
    // Nodal and const monomial variable
    else if (MooseUtils::absoluteFuzzyEqual(
                 dofobject_to_valsvec[problem_id].find(dof_object_id)->second.distance, distance))
      overlap_found = true;

    // Map will only keep the actual overlaps
    if (!overlap_found)
      _received_conflicts.erase(conflict_it);
    else
      ++conflict_it;
  }
}

execute()

void MultiAppGeneralFieldTransfer::execute ( )

overridevirtual

Execute the transfer.

Implements Transfer.

Reimplemented in MultiAppGeneralFieldUserObjectTransfer.

Definition at line 459 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldUserObjectTransfer::execute().

{
  TIME_SECTION(
      "MultiAppGeneralFieldTransfer::execute()_" + name(), 5, "Transfer execution " + name());
  getAppInfo();

  // Set up bounding boxes, etc
  prepareToTransfer();

  // loop over the vector of variables and make the transfer one by one
  for (const auto i : make_range(_var_size))
    transferVariable(i);

  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 466 of file MultiAppTransfer.C.

Referenced by MultiAppTransfer::getFromBoundingBoxes(), and 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;
  }
}

extractLocalFromBoundingBoxes()

void MultiAppGeneralFieldTransfer::extractLocalFromBoundingBoxes ( std::vector< BoundingBox > &  local_bboxes )

protected

Definition at line 892 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldShapeEvaluationTransfer::prepareEvaluationOfInterpValues(), and MultiAppGeneralFieldUserObjectTransfer::prepareEvaluationOfInterpValues().

{
  local_bboxes.resize(_froms_per_proc[processor_id()]);
  // Find the index to the first of this processor's local bounding boxes.
  unsigned int local_start = 0;
  for (processor_id_type i_proc = 0; i_proc < n_processors() && i_proc != processor_id(); ++i_proc)
    local_start += _froms_per_proc[i_proc];

  // Extract the local bounding boxes.
  for (const auto i_from : make_range(_froms_per_proc[processor_id()]))
    local_bboxes[i_from] = _from_bboxes[local_start + i_from];
}

extractOutgoingPoints()

void MultiAppGeneralFieldTransfer::extractOutgoingPoints ( const unsigned int  var_index, ProcessorToPointVec &  outgoing_points  )

private

Definition at line 749 of file MultiAppGeneralFieldTransfer.C.

Referenced by transferVariable().

{
  // Get the variable name, with the accommodation for array/vector names
  const auto & var_name = getToVarName(var_index);

  // Clean up the map from processor to pointInfo vector
  // This map should be consistent with outgoing_points
  _processor_to_pointInfoVec.clear();

  // Loop over all problems
  for (const auto i_to : index_range(_to_problems))
  {
    const auto global_i_to = getGlobalTargetAppIndex(i_to);

    // libMesh EquationSystems
    auto & es = getEquationSystem(*_to_problems[i_to], _displaced_target_mesh);
    // libMesh system that has this variable
    System * to_sys = find_sys(es, var_name);
    auto sys_num = to_sys->number();
    auto var_num = _to_variables[var_index]->number();
    auto & fe_type = _to_variables[var_index]->feType();
    bool is_nodal = _to_variables[var_index]->isNodal();

    // Moose mesh
    const auto & to_moose_mesh = _to_problems[i_to]->mesh(_displaced_target_mesh);
    const auto & to_mesh = to_moose_mesh.getMesh();

    // We support more general variables via libMesh GenericProjector
    if (fe_type.order > CONSTANT && !is_nodal)
    {
      GeneralFieldTransfer::RecordRequests<Number> f;
      GeneralFieldTransfer::RecordRequests<Gradient> g;
      GeneralFieldTransfer::NullAction<Number> nullsetter;
      const std::vector<unsigned int> varvec(1, var_num);

      libMesh::GenericProjector<GeneralFieldTransfer::RecordRequests<Number>,
                                GeneralFieldTransfer::RecordRequests<Gradient>,
                                Number,
                                GeneralFieldTransfer::NullAction<Number>>
          request_gather(*to_sys, f, &g, nullsetter, varvec);

      // Defining only boundary values will not be enough to describe the variable, disallow it
      if (_to_boundaries.size() && (_to_variables[var_index]->getContinuity() == DISCONTINUOUS))
        mooseError("Higher order discontinuous elemental variables are not supported for "
                   "target-boundary "
                   "restricted transfers");

      // Not implemented as the target mesh division could similarly be cutting elements in an
      // arbitrary way with not enough requested points to describe the target variable
      if (!_to_mesh_divisions.empty() && !_to_mesh_divisions[i_to]->coversEntireMesh())
        mooseError("Higher order variable support not implemented for target mesh division "
                   "unless the mesh is fully covered / indexed in the mesh division. This must be "
                   "set programmatically in the MeshDivision object used.");

      // We dont look at boundary restriction, not supported for higher order target variables
      // Same for mesh divisions
      const auto & to_begin = _to_blocks.empty()
                                  ? to_mesh.active_local_elements_begin()
                                  : to_mesh.active_local_subdomain_set_elements_begin(_to_blocks);

      const auto & to_end = _to_blocks.empty()
                                ? to_mesh.active_local_elements_end()
                                : to_mesh.active_local_subdomain_set_elements_end(_to_blocks);

      ConstElemRange to_elem_range(to_begin, to_end);

      request_gather.project(to_elem_range);

      dof_id_type point_id = 0;
      for (const Point & p : f.points_requested())
        // using the point number as a "dof_object_id" will serve to identify the point if we ever
        // rework interp/distance_cache into the dof_id_to_value maps
        this->cacheOutgoingPointInfo(
            (*_to_transforms[global_i_to])(p), point_id++, i_to, outgoing_points);

      // This is going to require more complicated transfer work
      if (!g.points_requested().empty())
        mooseError("We don't currently support variables with gradient degrees of freedom");
    }
    else if (is_nodal)
    {
      for (const auto & node : to_mesh.local_node_ptr_range())
      {
        // Skip this node if the variable has no dofs at it.
        if (node->n_dofs(sys_num, var_num) < 1)
          continue;

        // Skip if it is a block restricted transfer and current node does not have
        // specified blocks
        if (!_to_blocks.empty() && !inBlocks(_to_blocks, to_moose_mesh, node))
          continue;

        if (!_to_boundaries.empty() && !onBoundaries(_to_boundaries, to_moose_mesh, node))
          continue;

        // Skip if the node does not meet the target mesh division behavior
        // We cannot know from which app the data will come from so we cannot know
        // the source mesh division index and the source app global index
        if (!_to_mesh_divisions.empty() && _to_mesh_divisions[i_to]->divisionIndex(*node) ==
                                               MooseMeshDivision::INVALID_DIVISION_INDEX)
          continue;

        // Cache point information
        // We will use this information later for setting values back to solution vectors
        cacheOutgoingPointInfo(
            (*_to_transforms[global_i_to])(*node), node->id(), i_to, outgoing_points);
      }
    }
    else // Elemental, constant monomial
    {
      for (const auto & elem :
           as_range(to_mesh.local_elements_begin(), to_mesh.local_elements_end()))
      {
        // Skip this element if the variable has no dofs at it.
        if (elem->n_dofs(sys_num, var_num) < 1)
          continue;

        // Skip if the element is not inside the block restriction
        if (!_to_blocks.empty() && !inBlocks(_to_blocks, elem))
          continue;

        // Skip if the element does not have a side on the boundary
        if (!_to_boundaries.empty() && !onBoundaries(_to_boundaries, to_moose_mesh, elem))
          continue;

        // Skip if the element is not indexed within the mesh division
        if (!_to_mesh_divisions.empty() && _to_mesh_divisions[i_to]->divisionIndex(*elem) ==
                                               MooseMeshDivision::INVALID_DIVISION_INDEX)
          continue;

        // Cache point information
        // We will use this information later for setting values back to solution vectors
        cacheOutgoingPointInfo((*_to_transforms[global_i_to])(elem->vertex_average()),
                               elem->id(),
                               i_to,
                               outgoing_points);
      } // for
    } // else
  } // for
}

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 examineLocalValueConflicts(), examineReceivedValueConflicts(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), extractOutgoingPoints(), 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);
}

getAppInfo()

void MultiAppGeneralFieldTransfer::getAppInfo ( )

overridevirtual

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

Reimplemented from MultiAppTransfer.

Definition at line 443 of file MultiAppGeneralFieldTransfer.C.

Referenced by execute().

{
  MultiAppFieldTransfer::getAppInfo();

  // Create the point locators to locate evaluation points in the origin mesh(es)
  _from_point_locators.resize(_from_problems.size());
  for (const auto i_from : index_range(_from_problems))
  {
    const auto & from_moose_mesh = _from_problems[i_from]->mesh(_displaced_source_mesh);
    _from_point_locators[i_from] =
        PointLocatorBase::build(TREE_LOCAL_ELEMENTS, from_moose_mesh.getMesh());
    _from_point_locators[i_from]->enable_out_of_mesh_mode();
  }
}

getBase()

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

inlineinherited

Returns

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

Definition at line 143 of file MooseBase.h.

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

{ return _pars.getBase(); }

getCheckedPointerParam()

template<typename T >

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

inherited

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

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

Definition at line 428 of file MooseBase.h.

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

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.");

  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;

    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }

  if (error)
    _parent.mooseError(*error);

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

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

  return found_path.path;
}

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(), examineLocalValueConflicts(), examineReceivedValueConflicts(), extractOutgoingPoints(), 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(), Control::Control(), EigenExecutionerBase::init(), MultiAppConservativeTransfer::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), Terminator::initialSetup(), Exodus::outputSetup(), NodalReporter::shouldStore(), ElementReporter::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 496 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 530 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(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppCloneReporterTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeToMultiapp(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), initialSetup(), locatePointReceivers(), MultiAppGeneralFieldTransfer(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppUserObjectTransfer::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 591 of file MultiAppTransfer.C.

Referenced by MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), 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;
}

getFromVarName()

VariableName MultiAppGeneralFieldTransfer::getFromVarName

(

unsigned int

var_index

)

Get the source variable name, with the suffix for array/vector variables.

Definition at line 1948 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), and outputValueConflicts().

{
  mooseAssert(var_index < _from_var_names.size(), "No source variable at this index");
  VariableName var_name = _from_var_names[var_index];
  if (_from_var_components.size())
    var_name += "_" + std::to_string(_from_var_components[var_index]);
  return var_name;
}

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 648 of file MultiAppTransfer.C.

Referenced by acceptPointInOriginMesh(), acceptPointMeshDivision(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), examineLocalValueConflicts(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppGeneralFieldNearestLocationTransfer::getPointInLocalSourceFrame(), getRestrictedFromBoundingBoxes(), and 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];
}

getGlobalStartAppPerProc()

std::vector< unsigned int > MultiAppGeneralFieldTransfer::getGlobalStartAppPerProc ( ) const

private

Get global index for the first app each processes owns Requires a global communication, must be called on every domain simultaneously.

Definition at line 1938 of file MultiAppGeneralFieldTransfer.C.

Referenced by prepareToTransfer().

{
  std::vector<unsigned int> global_app_start_per_proc(1, -1);
  if (_from_local2global_map.size())
    global_app_start_per_proc[0] = _from_local2global_map[0];
  _communicator.allgather(global_app_start_per_proc, true);
  return global_app_start_per_proc;
}

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 656 of file MultiAppTransfer.C.

Referenced by cacheIncomingInterpVals(), cacheOutgoingPointInfo(), extractOutgoingPoints(), MultiAppTransfer::getPointInTargetAppFrame(), locatePointReceivers(), and 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];
}

getHitNode()

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

inlineinherited

Returns

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

Definition at line 132 of file MooseBase.h.

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

{ return getHitNode(_pars); }

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 664 of file MultiAppTransfer.C.

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

getMaxToProblemsBBoxDimensions()

Point MultiAppGeneralFieldTransfer::getMaxToProblemsBBoxDimensions ( ) const

private

Obtains the max dimensions to scale all points in the mesh.

Returns

the maximum dimension in each coordinate axis of all target problems

Definition at line 1968 of file MultiAppGeneralFieldTransfer.C.

Referenced by transferVariable().

{
  Point max_dimension = {std::numeric_limits<Real>::min(),
                         std::numeric_limits<Real>::min(),
                         std::numeric_limits<Real>::min()};

  for (const auto & to_mesh : _to_meshes)
  {
    const auto bbox = to_mesh->getInflatedProcessorBoundingBox();
    for (const auto dim : make_range(LIBMESH_DIM))
      max_dimension(dim) = std::max(
          max_dimension(dim), std::max(std::abs(bbox.first(dim)), std::abs(bbox.second(dim))));
  }

  return max_dimension;
}

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 83 of file MooseBase.h.

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

{ return _app; }

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 & MooseBase::getParam ( const std::string &  name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 384 of file MooseBase.h.

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

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

getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns

Vector of pairs of first and second parameters

Definition at line 421 of file MooseBase.h.

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

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 627 of file MultiAppTransfer.C.

Referenced by cacheIncomingInterpVals(), and 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 & MooseBase::getRenamedParam ( const std::string &  old_name, const std::string &  new_name  ) const

inherited

Retrieve a renamed parameter for the object.

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

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 398 of file MooseBase.h.

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

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

getRestrictedFromBoundingBoxes()

std::vector< BoundingBox > MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes ( ) const

private

Get from bounding boxes for given domains and boundaries.

Definition at line 1854 of file MultiAppGeneralFieldTransfer.C.

Referenced by prepareToTransfer().

{
  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 (const auto j : make_range(_from_meshes.size()))
  {
    Point min(max_r, max_r, max_r);
    Point max(min_r, min_r, min_r);
    bool at_least_one = false;
    const auto & from_mesh = _from_problems[j]->mesh(_displaced_source_mesh);

    for (const auto & elem : as_range(from_mesh.getMesh().local_elements_begin(),
                                      from_mesh.getMesh().local_elements_end()))
    {
      if (!_from_blocks.empty() && !inBlocks(_from_blocks, from_mesh, elem))
        continue;

      for (const auto & node : elem->node_ref_range())
      {
        if (!_from_boundaries.empty() && !onBoundaries(_from_boundaries, from_mesh, &node))
          continue;

        at_least_one = true;
        for (const auto i : make_range(LIBMESH_DIM))
        {
          min(i) = std::min(min(i), node(i));
          max(i) = std::max(max(i), node(i));
        }
      }
    }

    // For 2D RZ problems, we need to amend the bounding box to cover the whole XYZ projection
    // - The XYZ-Y axis is assumed aligned with the RZ-Z axis
    // - RZ systems also cover negative coordinates hence the use of the maximum R
    // NOTE: We will only support the case where there is only one coordinate system
    if ((from_mesh.getUniqueCoordSystem() == Moose::COORD_RZ) && (LIBMESH_DIM == 3))
    {
      min(0) = -max(0);
      min(2) = -max(0);
      max(2) = max(0);
    }

    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(j);
      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[j] = 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 (const auto i : make_range(bb_points.size()))
    bboxes[i] = static_cast<BoundingBox>(bb_points[i]);

  // TODO move up
  // Check for a user-set fixed bounding box size and modify the sizes as appropriate
  if (_fixed_bbox_size != std::vector<Real>(3, 0))
    for (const auto i : make_range(LIBMESH_DIM))
      if (!MooseUtils::absoluteFuzzyEqual(_fixed_bbox_size[i], 0))
        for (const auto j : make_range(bboxes.size()))
        {
          const auto current_width = (bboxes[j].second - bboxes[j].first)(i);
          bboxes[j].first(i) -= (_fixed_bbox_size[i] - current_width) / 2;
          bboxes[j].second(i) += (_fixed_bbox_size[i] - current_width) / 2;
        }

  return bboxes;
}

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 61 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

{
  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 74 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(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppReporterTransfer::executeFromMultiapp(), MultiAppReporterTransfer::executeToMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), initialSetup(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppUserObjectTransfer::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";
  }

getToVarName()

VariableName MultiAppGeneralFieldTransfer::getToVarName

(

unsigned int

var_index

)

Get the target variable name, with the suffix for array/vector variables.

Definition at line 1958 of file MultiAppGeneralFieldTransfer.C.

Referenced by examineLocalValueConflicts(), examineReceivedValueConflicts(), extractOutgoingPoints(), outputValueConflicts(), and setSolutionVectorValues().

{
  mooseAssert(var_index < _to_var_names.size(), "No target variable at this index");
  VariableName var_name = _to_var_names[var_index];
  if (_to_var_components.size())
    var_name += "_" + std::to_string(_to_var_components[var_index]);
  return var_name;
}

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

hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns

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

Definition at line 138 of file MooseBase.h.

{ return _pars.hasBase(); }

hasFromMultiApp()

bool MultiAppTransfer::hasFromMultiApp ( ) const

inlineinherited

Whether the transfer owns a non-null from_multi_app.

Definition at line 107 of file MultiAppTransfer.h.

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

{ return !(!_from_multi_app); }

hasToMultiApp()

bool MultiAppTransfer::hasToMultiApp ( ) const

inlineinherited

Whether the transfer owns a non-null to_multi_app.

Definition at line 110 of file MultiAppTransfer.h.

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

{ return !(!_to_multi_app); }

inBlocks() [1/4]

bool MultiAppGeneralFieldTransfer::inBlocks ( const std::set< SubdomainID > &  blocks, const Elem *  elem  ) const

protected

Referenced by acceptPointInOriginMesh(), extractOutgoingPoints(), and getRestrictedFromBoundingBoxes().

inBlocks() [2/4]

virtual bool MultiAppGeneralFieldTransfer::inBlocks ( const std::set< SubdomainID > &  blocks, const MooseMesh &  mesh, const Elem *  elem  ) const

protectedvirtual

Reimplemented in MultiAppGeneralFieldNearestLocationTransfer.

inBlocks() [3/4]

bool MultiAppGeneralFieldTransfer::inBlocks ( const std::set< SubdomainID > &  blocks, const MooseMesh &  mesh, const Node *  node  ) const

protected

inBlocks() [4/4]

bool MultiAppGeneralFieldTransfer::inBlocks ( const std::set< SubdomainID > &  blocks, const libMesh::PointLocatorBase *const  pl, const Point &  pt  ) const

protected

initialSetup()

void MultiAppGeneralFieldTransfer::initialSetup ( )

overridevirtual

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

Reimplemented from MultiAppConservativeTransfer.

Reimplemented in MultiAppGeneralFieldNearestLocationTransfer.

Definition at line 227 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::initialSetup().

{
  MultiAppConservativeTransfer::initialSetup();

  // Use IDs for block and boundary restriction
  // Loop over all source problems
  for (const auto i_from : index_range(_from_problems))
  {
    const auto & from_moose_mesh = _from_problems[i_from]->mesh(_displaced_source_mesh);
    if (isParamValid("from_blocks"))
    {
      const auto & block_names = getParam<std::vector<SubdomainName>>("from_blocks");

      for (const auto & b : block_names)
        if (!MooseMeshUtils::hasSubdomainName(from_moose_mesh.getMesh(), b))
          paramError("from_blocks", "The block '", b, "' was not found in the mesh");

      if (!block_names.empty())
      {
        const auto ids = from_moose_mesh.getSubdomainIDs(block_names);
        _from_blocks.insert(ids.begin(), ids.end());
      }
    }

    if (isParamValid("from_boundaries"))
    {
      const auto & boundary_names = getParam<std::vector<BoundaryName>>("from_boundaries");
      for (const auto & bn : boundary_names)
        if (!MooseMeshUtils::hasBoundaryName(from_moose_mesh.getMesh(), bn))
          paramError("from_boundaries", "The boundary '", bn, "' was not found in the mesh");

      if (!boundary_names.empty())
      {
        const auto boundary_ids = from_moose_mesh.getBoundaryIDs(boundary_names);
        _from_boundaries.insert(boundary_ids.begin(), boundary_ids.end());
      }
    }

    if (isParamValid("from_mesh_division"))
    {
      const auto & mesh_div_name = getParam<MeshDivisionName>("from_mesh_division");
      _from_mesh_divisions.push_back(&_from_problems[i_from]->getMeshDivision(mesh_div_name));
      // Check that the behavior set makes sense
      if (_from_mesh_division_behavior == MeshDivisionTransferUse::RESTRICTION)
      {
        if (_from_mesh_divisions[i_from]->coversEntireMesh())
          mooseInfo("'from_mesh_division_usage' is set to use a spatial restriction but the "
                    "'from_mesh_division' for source app of global index " +
                    std::to_string(getGlobalSourceAppIndex(i_from)) +
                    " covers the entire mesh. Do not expect any restriction from a mesh "
                    "division that covers the entire mesh");
      }
      else if (_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX &&
               !isParamValid("to_mesh_division"))
        paramError("to_mesh_division_usage",
                   "Source mesh division cannot match target mesh division if no target mesh "
                   "division is specified");
      else if (_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX)
      {
        if (!hasToMultiApp())
          paramError("from_mesh_division_usage",
                     "Cannot match source mesh division index to target subapp index if there is "
                     "only one target: the parent app (not a subapp)");
        else if (getToMultiApp()->numGlobalApps() !=
                 _from_mesh_divisions[i_from]->getNumDivisions())
          mooseWarning("Attempting to match target subapp index with the number of source mesh "
                       "divisions, which is " +
                       std::to_string(_from_mesh_divisions[i_from]->getNumDivisions()) +
                       " while there are " + std::to_string(getToMultiApp()->numGlobalApps()) +
                       " target subapps");
        if (_to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX)
          // We do not support it because it would require sending the point + target app index +
          // target app division index, and we only send the Point + one number
          paramError("from_mesh_division_usage",
                     "We do not support using target subapp index for source division behavior and "
                     "matching the division index for the target mesh division behavior.");
      }
      else if (_from_mesh_division_behavior == "none")
        paramError("from_mesh_division_usage", "User must specify a 'from_mesh_division_usage'");
    }
    else if (_from_mesh_division_behavior != "none")
      paramError("from_mesh_division",
                 "'from_mesh_division' must be specified if the usage method is specified");
  }

  // Loop over all target problems
  for (const auto i_to : index_range(_to_problems))
  {
    const auto & to_moose_mesh = _to_problems[i_to]->mesh(_displaced_target_mesh);
    if (isParamValid("to_blocks"))
    {
      const auto & block_names = getParam<std::vector<SubdomainName>>("to_blocks");
      for (const auto & b : block_names)
        if (!MooseMeshUtils::hasSubdomainName(to_moose_mesh.getMesh(), b))
          paramError("to_blocks", "The block '", b, "' was not found in the mesh");

      if (!block_names.empty())
      {
        const auto ids = to_moose_mesh.getSubdomainIDs(block_names);
        _to_blocks.insert(ids.begin(), ids.end());
      }
    }

    if (isParamValid("to_boundaries"))
    {
      const auto & boundary_names = getParam<std::vector<BoundaryName>>("to_boundaries");
      for (const auto & bn : boundary_names)
        if (!MooseMeshUtils::hasBoundaryName(to_moose_mesh.getMesh(), bn))
          paramError("to_boundaries", "The boundary '", bn, "' was not found in the mesh");

      if (!boundary_names.empty())
      {
        const auto boundary_ids = to_moose_mesh.getBoundaryIDs(boundary_names);
        _to_boundaries.insert(boundary_ids.begin(), boundary_ids.end());
      }
    }

    if (isParamValid("to_mesh_division"))
    {
      const auto & mesh_div_name = getParam<MeshDivisionName>("to_mesh_division");
      _to_mesh_divisions.push_back(&_to_problems[i_to]->getMeshDivision(mesh_div_name));
      // Check that the behavior set makes sense
      if (_to_mesh_division_behavior == MeshDivisionTransferUse::RESTRICTION)
      {
        if (_to_mesh_divisions[i_to]->coversEntireMesh())
          mooseInfo("'to_mesh_division_usage' is set to use a spatial restriction but the "
                    "'to_mesh_division' for target application of global index " +
                    std::to_string(getGlobalSourceAppIndex(i_to)) +
                    " covers the entire mesh. Do not expect any restriction from a mesh "
                    "division that covers the entire mesh");
      }
      else if (_to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX)
      {
        if (!isParamValid("from_mesh_division"))
          paramError("to_mesh_division_usage",
                     "Target mesh division cannot match source mesh division if no source mesh "
                     "division is specified");
        else if ((*_from_mesh_divisions.begin())->getNumDivisions() !=
                 _to_mesh_divisions[i_to]->getNumDivisions())
          mooseWarning("Source and target mesh divisions do not have the same number of bins. If "
                       "this is what you expect, please reach out to a MOOSE or app developer to "
                       "ensure appropriate use");
      }
      else if (_to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX)
      {
        if (!hasFromMultiApp())
          paramError(
              "to_mesh_division_usage",
              "Cannot match target mesh division index to source subapp index if there is only one "
              "source: the parent app (not a subapp)");
        else if (getFromMultiApp()->numGlobalApps() != _to_mesh_divisions[i_to]->getNumDivisions())
          mooseWarning("Attempting to match source subapp index with the number of target mesh "
                       "divisions, which is " +
                       std::to_string(_to_mesh_divisions[i_to]->getNumDivisions()) +
                       " while there are " + std::to_string(getFromMultiApp()->numGlobalApps()) +
                       " source subapps");
        if (_from_mesh_division_behavior == MeshDivisionTransferUse::MATCH_DIVISION_INDEX)
          paramError(
              "from_mesh_division_usage",
              "We do not support using source subapp index for the target division behavior and "
              "matching the division index for the source mesh division behavior.");
      }
      else if (_to_mesh_division_behavior == "none")
        paramError("to_mesh_division_usage", "User must specify a 'to_mesh_division_usage'");
    }
    else if (_to_mesh_division_behavior != "none")
      paramError("to_mesh_division",
                 "'to_mesh_division' must be specified if usage method '" +
                     Moose::stringify(_to_mesh_division_behavior) + "' is specified");
  }

  // Check if components are set correctly if using an array variable
  for (const auto i_from : index_range(_from_problems))
  {
    for (const auto var_index : make_range(_from_var_names.size()))
    {
      MooseVariableFieldBase & from_var =
          _from_problems[i_from]->getVariable(0,
                                              _from_var_names[var_index],
                                              Moose::VarKindType::VAR_ANY,
                                              Moose::VarFieldType::VAR_FIELD_ANY);
      if (from_var.count() > 1 && _from_var_components.empty())
        paramError("source_variable_components", "Component must be passed for an array variable");
      if (_from_var_components.size() && from_var.count() < _from_var_components[var_index])
        paramError("source_variable_components",
                   "Component passed is larger than size of variable");
    }
  }
  for (const auto i_to : index_range(_to_problems))
  {
    for (const auto var_index : make_range(_to_var_names.size()))
    {
      MooseVariableFieldBase & to_var =
          _to_problems[i_to]->getVariable(0,
                                          _to_var_names[var_index],
                                          Moose::VarKindType::VAR_ANY,
                                          Moose::VarFieldType::VAR_FIELD_ANY);
      if (to_var.count() > 1 && _to_var_components.empty())
        paramError("target_variable_components", "Component must be passed for an array variable");
      if (_to_var_components.size() && to_var.count() < _to_var_components[var_index])
        paramError("target_variable_components",
                   "Component passed is larger than size of variable");
    }
  }

  // Cache some quantities to avoid having to get them on every transferred point
  if (_to_problems.size())
  {
    _to_variables.resize(_to_var_names.size());
    for (const auto i_var : index_range(_to_var_names))
      _to_variables[i_var] = &_to_problems[0]->getVariable(
          0, _to_var_names[i_var], Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
  }
}

inMesh()

bool MultiAppGeneralFieldTransfer::inMesh ( const libMesh::PointLocatorBase *const  pl, const Point &  pt  ) const

protected

Definition at line 1620 of file MultiAppGeneralFieldTransfer.C.

Referenced by acceptPointInOriginMesh(), and MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource().

{
  // Note: we do not take advantage of a potential block restriction of the mesh here. This is
  // because we can avoid this routine by calling inBlocks() instead
  const Elem * elem = (*pl)(point);
  return (elem != nullptr);
}

isParamSetByUser()

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

inlineinherited

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

Parameters

name	The name of the parameter to test

Definition at line 201 of file MooseBase.h.

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

  {
    return _pars.isParamSetByUser(name);
  }

isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 195 of file MooseBase.h.

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

{ return _pars.isParamValid(name); }

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< RT >, MooseVariableField< ComputeValueType >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, Positions, Times, DiffusionLHDGKernel, IPHDGKernel, EqualValueEmbeddedConstraintTempl< is_ad >, ADKernelTempl< T >, IPHDGBC, DiffusionLHDGPrescribedGradientBC, and DiffusionLHDGDirichletBC.

Definition at line 51 of file SetupInterface.C.

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

{
}

locatePointReceivers()

void MultiAppGeneralFieldTransfer::locatePointReceivers ( const Point  point, std::set< processor_id_type > &  processors  )

private

Definition at line 578 of file MultiAppGeneralFieldTransfer.C.

Referenced by cacheOutgoingPointInfo().

{
  // Check which processors have apps that may include or be near this point
  // A point may be close enough to several problems, hosted on several processes
  bool found = false;

  // Additional process-restriction techniques we could use (TODOs):
  // - create a heuristic for using nearest-positions
  // - from_mesh_divisions could be polled for which divisions they possess on each
  //   process, depending on the behavior chosen. This could limit potential senders.
  //   This should be done ahead of this function call, for all points at once

  // Determine the apps which will be receiving points (then sending values) using various
  // heuristics
  if (_use_nearest_app)
  {
    // Find the nearest position for the point
    const bool initial = _fe_problem.getCurrentExecuteOnFlag() == EXEC_INITIAL;
    // The apps form the nearest positions here, this is the index of the nearest app
    const auto nearest_index = _nearest_positions_obj->getNearestPositionIndex(point, initial);

    // Find the apps that are nearest to the same position
    // Global search over all applications
    for (processor_id_type i_proc = 0; i_proc < n_processors(); ++i_proc)
    {
      // We need i_from to correspond to the global app index
      unsigned int from0 = _global_app_start_per_proc[i_proc];
      for (unsigned int i_from = from0; i_from < from0 + _froms_per_proc[i_proc]; ++i_from)
      {
        if (_greedy_search || _search_value_conflicts || i_from == nearest_index)
        {
          processors.insert(i_proc);
          found = true;
        }
        mooseAssert(i_from < getFromMultiApp()->numGlobalApps(), "We should not reach this");
      }
    }
    mooseAssert((getFromMultiApp()->numGlobalApps() < n_processors() || processors.size() == 1) ||
                    _greedy_search || _search_value_conflicts,
                "Should only be one source processor when using more processors than source apps");
  }
  else if (_use_bounding_boxes)
  {
    // We examine all (global) bounding boxes and find the minimum of the maximum distances within a
    // bounding box from the point. This creates a sphere around the point of interest. Any app
    // with a bounding box that intersects this sphere (with a bboxMinDistance <
    // nearest_max_distance) will be considered a potential source
    // NOTE: This is a heuristic. We could try others
    // NOTE: from_bboxes are in the reference space, as is the point.
    Real nearest_max_distance = std::numeric_limits<Real>::max();
    for (const auto & bbox : _from_bboxes)
    {
      Real distance = bboxMaxDistance(point, bbox);
      if (distance < nearest_max_distance)
        nearest_max_distance = distance;
    }

    unsigned int from0 = 0;
    for (processor_id_type i_proc = 0; i_proc < n_processors();
         from0 += _froms_per_proc[i_proc], ++i_proc)
      // i_from here is a hybrid index based on the cumulative sum of the apps per processor
      for (unsigned int i_from = from0; i_from < from0 + _froms_per_proc[i_proc]; ++i_from)
      {
        Real distance = bboxMinDistance(point, _from_bboxes[i_from]);
        // We will not break here because we want to send a point to all possible source domains
        if (_greedy_search || distance <= nearest_max_distance ||
            _from_bboxes[i_from].contains_point(point))
        {
          processors.insert(i_proc);
          found = true;
        }
      }
  }
  // Greedy search will contact every single processor. It's not scalable, but if there's valid data
  // on any subapp on any process, it will find it
  else if (_greedy_search)
  {
    found = true;
    for (const auto i_proc : make_range(n_processors()))
      processors.insert(i_proc);
  }
  // Since we indicated that we only wanted values from a subapp with the same global index as the
  // target mesh division, we might as well only communicate with the process that owns this app
  else if (!_to_mesh_divisions.empty() &&
           _to_mesh_division_behavior == MeshDivisionTransferUse::MATCH_SUBAPP_INDEX)
  {
    // The target point could have a different index in each target mesh division. So on paper, we
    // would need to check all of them.
    auto saved_target_div = MooseMeshDivision::INVALID_DIVISION_INDEX;
    for (const auto i_to : index_range(_to_meshes))
    {
      const auto target_div = _to_mesh_divisions[i_to]->divisionIndex(
          _to_transforms[getGlobalTargetAppIndex(i_to)]->mapBack(point));
      // If it's the same division index, do not redo the search
      if (target_div == saved_target_div)
        continue;
      else
        saved_target_div = target_div;

      // Look for the processors owning a source-app with an index equal to the target mesh division
      for (const auto i_proc : make_range(n_processors()))
        for (const auto i_from : make_range(_froms_per_proc[i_proc]))
          if (target_div == _global_app_start_per_proc[i_proc] + i_from)
          {
            processors.insert(i_proc);
            found = true;
          }
    }
  }
  else
    mooseError("No algorithm were selected to find which processes may send value data "
               "for a each target point. Please either specify using bounding boxes, "
               "greedy search, or to_mesh_division-based parameters");

  // Error out if we could not find this point when ask us to do so
  if (!found && _error_on_miss)
    mooseError(
        "Cannot find a source application to provide a value at point: ",
        point,
        " \n ",
        "It must be that mismatched meshes, between the source and target application, are being "
        "used.\nIf you are using the bounding boxes or nearest-app heuristics, or mesh-divisions, "
        "please consider using the greedy_search to confirm. Then consider choosing a different "
        "transfer type.\nThis check can be turned off by setting 'error_on_miss' to false. The "
        "'extrapolation_constant' parameter will be used to set the local value at missed points.");
}

messagePrefix()

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

inlineinherited

Returns

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

Definition at line 252 of file MooseBase.h.

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

  {
    return messagePrefix(_pars, hit_prefix);
  }

mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 310 of file MooseBase.h.

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

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

mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 273 of file MooseBase.h.

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

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

mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 267 of file MooseBase.h.

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

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

mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 286 of file MooseBase.h.

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

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 317 of file MooseBase.h.

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

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

mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 295 of file MooseBase.h.

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

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

mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 304 of file MooseBase.h.

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

name()

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

inlineinherited

Get the name of the class.

Returns

The name of the class

Definition at line 99 of file MooseBase.h.

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

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

onBoundaries() [1/3]

bool MultiAppGeneralFieldTransfer::onBoundaries ( const std::set< BoundaryID > &  boundaries, const MooseMesh &  mesh, const Node *  node  ) const

protected

Referenced by acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), extractOutgoingPoints(), and getRestrictedFromBoundingBoxes().

onBoundaries() [2/3]

bool MultiAppGeneralFieldTransfer::onBoundaries ( const std::set< BoundaryID > &  boundaries, const MooseMesh &  mesh, const Elem *  elem  ) const

protected

onBoundaries() [3/3]

bool MultiAppGeneralFieldTransfer::onBoundaries ( const std::set< BoundaryID > &  boundaries, const std::set< SubdomainID > &  block_restriction, const MooseMesh &  mesh, const libMesh::PointLocatorBase *const  pl, const Point &  pt  ) const

protected

outputValueConflicts()

void MultiAppGeneralFieldTransfer::outputValueConflicts ( const unsigned int  var_index, const DofobjectToInterpValVec &  dofobject_to_valsvec, const InterpCaches &  distance_caches  )

private

Report on conflicts between overlapping child apps, equidistant origin points etc.

Definition at line 1287 of file MultiAppGeneralFieldTransfer.C.

Referenced by transferVariable().

{
  // Remove potential conflicts that did not materialize, the value did not end up being used
  examineReceivedValueConflicts(var_index, dofobject_to_valsvec, distance_caches);
  examineLocalValueConflicts(var_index, dofobject_to_valsvec, distance_caches);

  // Output the conflicts from the selection of local values (evaluateInterpValues-type routines)
  // to send in response to value requests at target points
  const std::string rank_str = std::to_string(_communicator.rank());
  if (_local_conflicts.size())
  {
    unsigned int num_outputs = 0;
    std::string local_conflicts_string = "";
    std::string potential_reasons =
        "Are some points in target mesh equidistant from the sources "
        "(nodes/centroids/apps/positions, depending on transfer) in origin mesh(es)?\n";
    if (hasFromMultiApp() && _from_problems.size() > 1)
      potential_reasons += "Are multiple subapps overlapping?\n";
    for (const auto & conflict : _local_conflicts)
    {
      const unsigned int problem_id = std::get<0>(conflict);
      Point p = std::get<2>(conflict);
      num_outputs++;

      std::string origin_domain_message;
      if (hasFromMultiApp() && !_nearest_positions_obj)
      {
        // NOTES:
        // - The origin app for a conflict may not be unique.
        // - The conflicts vectors only store the conflictual points, not the original one
        //   The original value found with a given distance could be retrieved from the main
        //   caches
        const auto app_id = _from_local2global_map[problem_id];
        origin_domain_message = "In source child app " + std::to_string(app_id) + " mesh,";
      }
      // We can't locate the source app when considering nearest positions, so we saved the data
      // in the reference space. So we return the conflict location in the target app (parent or
      // sibling) instead
      else if (hasFromMultiApp() && _nearest_positions_obj)
      {
        if (_to_problems.size() == 1 || _skip_coordinate_collapsing)
        {
          p = (*_to_transforms[0])(p);
          origin_domain_message = "In target app mesh,";
        }
        else
          origin_domain_message = "In reference (post-coordinate collapse) mesh,";
      }
      else
        origin_domain_message = "In source parent app mesh,";

      if (num_outputs < _search_value_conflicts_max_log)
        local_conflicts_string += origin_domain_message + " point: (" + std::to_string(p(0)) +
                                  ", " + std::to_string(p(1)) + ", " + std::to_string(p(2)) +
                                  "), equi-distance: " + std::to_string(std::get<3>(conflict)) +
                                  "\n";
      else if (num_outputs == _search_value_conflicts_max_log)
        local_conflicts_string +=
            "Maximum output of the search for value conflicts has been reached. Further conflicts "
            "will not be output.\nIncrease 'search_value_conflicts_max_log' to output more.";
    }
    // Explicitly name source to give more context
    std::string source_str = "unknown";
    if (_from_var_names.size())
      source_str = "variable '" + getFromVarName(var_index) + "'";
    else if (isParamValid("source_user_object"))
      source_str = "user object '" + getParam<UserObjectName>("source_user_object") + "'";

    mooseWarning("On rank " + rank_str +
                 ", multiple valid values from equidistant points were "
                 "found in the origin mesh for source " +
                 source_str + " for " + std::to_string(_local_conflicts.size()) +
                 " target points.\n" + potential_reasons + "Conflicts detected at :\n" +
                 local_conflicts_string);
  }

  // Output the conflicts discovered when receiving values from multiple origin problems
  if (_received_conflicts.size())
  {
    unsigned int num_outputs = 0;
    std::string received_conflicts_string = "";
    std::string potential_reasons =
        "Are some points in target mesh equidistant from the sources "
        "(nodes/centroids/apps/positions, depending on transfer) in origin mesh(es)?\n";
    if (hasToMultiApp() && _to_problems.size() > 1)
      potential_reasons += "Are multiple subapps overlapping?\n";
    for (const auto & conflict : _received_conflicts)
    {
      // Extract info for the potential overlap
      const unsigned int problem_id = std::get<0>(conflict);
      const Point p = std::get<2>(conflict);
      num_outputs++;

      std::string target_domain_message;
      if (hasToMultiApp())
      {
        const auto app_id = _to_local2global_map[problem_id];
        target_domain_message = "In target child app " + std::to_string(app_id) + " mesh,";
      }
      else
        target_domain_message = "In target parent app mesh,";

      if (num_outputs < _search_value_conflicts_max_log)
        received_conflicts_string += target_domain_message + " point: (" + std::to_string(p(0)) +
                                     ", " + std::to_string(p(1)) + ", " + std::to_string(p(2)) +
                                     "), equi-distance: " + std::to_string(std::get<3>(conflict)) +
                                     "\n";
      else if (num_outputs == _search_value_conflicts_max_log)
        received_conflicts_string +=
            "Maximum output of the search for value conflicts has been reached. Further conflicts "
            "will not be output.\nIncrease 'search_value_conflicts_max_log' to output more.";
    }
    mooseWarning("On rank " + rank_str +
                 ", multiple valid values from equidistant points were "
                 "received for target variable '" +
                 getToVarName(var_index) + "' for " + std::to_string(_received_conflicts.size()) +
                 " target points.\n" + potential_reasons + "Conflicts detected at :\n" +
                 received_conflicts_string);
  }

  if (_local_conflicts.empty() && _received_conflicts.empty())
  {
    if (isParamSetByUser("search_value_conflict"))
      mooseInfo("Automated diagnosis did not detect floating point indetermination in transfer");
    else if (_to_problems.size() > 10 || _from_problems.size() > 10 || _communicator.size() > 10)
      mooseInfo(
          "Automated diagnosis did not detect any floating point indetermination in "
          "the transfer. You may consider turning it off using `search_value_conflicts=false` "
          "to improve performance/scalability.");
  }

  // Reset the conflicts vectors, to be used for checking conflicts when transferring the next
  // variable
  _local_conflicts.clear();
  _received_conflicts.clear();
}

paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 435 of file MooseBase.h.

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

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

parameters()

const InputParameters& MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 127 of file MooseBase.h.

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

{ return _pars; }

paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 449 of file MooseBase.h.

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

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

paramWarning()

template<typename... Args>

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

inherited

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

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

Definition at line 442 of file MooseBase.h.

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

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

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

{
  return _pg_moose_app.perfGraph();
}

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 MultiAppGeneralFieldTransfer::postExecute ( )

overridevirtual

Add some extra work if necessary after execute().

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

Reimplemented from MultiAppConservativeTransfer.

Definition at line 502 of file MultiAppGeneralFieldTransfer.C.

Referenced by execute().

{
  MultiAppConservativeTransfer::postExecute();
  if (_search_value_conflicts)
    _already_output_search_value_conflicts = true;
}

prepareEvaluationOfInterpValues()

virtual void MultiAppGeneralFieldTransfer::prepareEvaluationOfInterpValues ( const unsigned int  var_index )

protectedpure virtual

Implemented in MultiAppGeneralFieldNearestLocationTransfer, MultiAppGeneralFieldUserObjectTransfer, and MultiAppGeneralFieldShapeEvaluationTransfer.

Referenced by transferVariable().

prepareToTransfer()

void MultiAppGeneralFieldTransfer::prepareToTransfer ( )

private

Initialize supporting attributes like bounding boxes, processor app indexes etc.

Definition at line 476 of file MultiAppGeneralFieldTransfer.C.

Referenced by execute().

{
  // Get the bounding boxes for the "from" domains.
  // Clean up _from_bboxes from the previous transfer execution
  _from_bboxes.clear();

  // NOTE: This ignores the app's bounding box inflation and padding
  _from_bboxes = getRestrictedFromBoundingBoxes();

  // Expand bounding boxes. Some desired points might be excluded
  // without an expansion
  extendBoundingBoxes(_bbox_factor, _from_bboxes);

  // Figure out how many "from" domains each processor owns.
  _froms_per_proc.clear();
  _froms_per_proc = getFromsPerProc();

  // Get the index for the first source app every processor owns
  _global_app_start_per_proc = getGlobalStartAppPerProc();

  // No need to keep searching for conflicts if the mesh has not changed
  if (_already_output_search_value_conflicts && !_displaced_source_mesh && !_displaced_target_mesh)
    _search_value_conflicts = false;
}

queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns

A pointer to the parameter value, if it exists

Definition at line 391 of file MooseBase.h.

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

registerConflict()

void MultiAppGeneralFieldTransfer::registerConflict ( unsigned int  problem, dof_id_type  dof_id, Point  p, Real  dist, bool  local  )

protected

Register a potential value conflict, e.g.

two or more equidistant source points for a single target point, with different values possible

Parameters

problem	problem ID for the point of interest. For local conflicts, use origin problem id, for received conflicts, use target id
dof_id	id id of the DoF is transferring a DoF. If not, use -1
p	point where the conflict happens
dist	distance between the origin and the target
local	if true, local conflict found when gathering data to send, if false, received value conflict found when receiving data from multiple source problems

Definition at line 1051 of file MultiAppGeneralFieldTransfer.C.

Referenced by cacheIncomingInterpVals(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), and MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects().

{
  // NOTE We could be registering the same conflict several times, we could count them instead
  if (local)
    _local_conflicts.push_back(std::make_tuple(problem, dof_id, p, dist));
  else
    _received_conflicts.push_back(std::make_tuple(problem, dof_id, p, dist));
}

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< RT >, MooseVariableField< ComputeValueType >, 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;
  }

setSolutionVectorValues()

void MultiAppGeneralFieldTransfer::setSolutionVectorValues ( const unsigned int  var_index, const DofobjectToInterpValVec &  dofobject_to_valsvec, const InterpCaches &  interp_caches  )

private

Definition at line 1428 of file MultiAppGeneralFieldTransfer.C.

Referenced by transferVariable().

{
  // Get the variable name, with the accommodation for array/vector names
  const auto & var_name = getToVarName(var_index);

  for (const auto problem_id : index_range(_to_problems))
  {
    auto & dofobject_to_val = dofobject_to_valsvec[problem_id];

    // libMesh EquationSystems
    // NOTE: we would expect to set variables from the displaced equation system here
    auto & es = getEquationSystem(*_to_problems[problem_id], false);

    // libMesh system
    System * to_sys = find_sys(es, var_name);

    // libMesh mesh
    const MeshBase & to_mesh = _to_problems[problem_id]->mesh(_displaced_target_mesh).getMesh();
    auto var_num = to_sys->variable_number(var_name);
    auto sys_num = to_sys->number();

    auto & fe_type = _to_variables[var_index]->feType();
    bool is_nodal = _to_variables[var_index]->isNodal();

    if (fe_type.order > CONSTANT && !is_nodal)
    {
      // We may need to use existing data values in places where the
      // from app domain doesn't overlap
      MeshFunction to_func(es, *to_sys->current_local_solution, to_sys->get_dof_map(), var_num);
      to_func.init();

      GeneralFieldTransfer::CachedData<Number> f(
          interp_caches[problem_id], to_func, _default_extrapolation_value);
      libMesh::VectorSetAction<Number> setter(*to_sys->solution);
      const std::vector<unsigned int> varvec(1, var_num);

      libMesh::GenericProjector<GeneralFieldTransfer::CachedData<Number>,
                                GeneralFieldTransfer::CachedData<Gradient>,
                                Number,
                                libMesh::VectorSetAction<Number>>
          set_solution(*to_sys, f, nullptr, setter, varvec);

      // We dont look at boundary restriction, not supported for higher order target variables
      const auto & to_begin = _to_blocks.empty()
                                  ? to_mesh.active_local_elements_begin()
                                  : to_mesh.active_local_subdomain_set_elements_begin(_to_blocks);

      const auto & to_end = _to_blocks.empty()
                                ? to_mesh.active_local_elements_end()
                                : to_mesh.active_local_subdomain_set_elements_end(_to_blocks);

      ConstElemRange active_local_elem_range(to_begin, to_end);

      set_solution.project(active_local_elem_range);
    }
    else
    {
      for (const auto & val_pair : dofobject_to_val)
      {
        const auto dof_object_id = val_pair.first;

        const DofObject * dof_object = nullptr;
        if (is_nodal)
          dof_object = to_mesh.node_ptr(dof_object_id);
        else
          dof_object = to_mesh.elem_ptr(dof_object_id);

        const auto dof = dof_object->dof_number(sys_num, var_num, 0);
        const auto val = val_pair.second.interp;

        // This will happen if meshes are mismatched
        if (_error_on_miss && GeneralFieldTransfer::isBetterOutOfMeshValue(val))
        {
          const auto target_location =
              hasToMultiApp()
                  ? " on target app " + std::to_string(getGlobalTargetAppIndex(problem_id))
                  : " on parent app";
          const auto info_msg = "\nThis check can be turned off by setting 'error_on_miss' to "
                                "false. The 'extrapolation_constant' parameter will be used to set "
                                "the local value at missed points.";
          if (is_nodal)
            mooseError("No source value for node ",
                       dof_object_id,
                       target_location,
                       " could be located. Node details:\n",
                       _to_meshes[problem_id]->nodePtr(dof_object_id)->get_info(),
                       "\n",
                       info_msg);
          else
            mooseError("No source value for element ",
                       dof_object_id,
                       target_location,
                       " could be located. Element details:\n",
                       _to_meshes[problem_id]->elemPtr(dof_object_id)->get_info(),
                       "\n",
                       info_msg);
        }

        // We should not put garbage into our solution vector
        // but it can be that we want to set it to a different value than what was already there
        // for example: the source app has been displaced and was sending an indicator of its
        // position
        if (GeneralFieldTransfer::isBetterOutOfMeshValue(val))
        {
          if (!GeneralFieldTransfer::isBetterOutOfMeshValue(_default_extrapolation_value))
            to_sys->solution->set(dof, _default_extrapolation_value);
          continue;
        }

        to_sys->solution->set(dof, val);
      }
    }

    to_sys->solution->close();
    // Sync local solutions
    to_sys->update();
  }
}

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< RT >, MooseVariableField< ComputeValueType >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, Function, Positions, Times, ElementSubdomainModifierBase, SolutionUserObjectBase, Console, VectorPostprocessorVisualizationAux, EqualValueEmbeddedConstraintTempl< is_ad >, NumNonlinearIterations, VectorMemoryUsage, JSONOutput, and MemoryUsage.

Definition at line 46 of file SetupInterface.C.

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

{
}

transferVariable()

void MultiAppGeneralFieldTransfer::transferVariable ( unsigned int  i )

private

Performs the transfer for the variable of index i.

Definition at line 510 of file MultiAppGeneralFieldTransfer.C.

Referenced by execute().

{
  mooseAssert(i < _var_size, "The variable of index " << i << " does not exist");

  // Find outgoing target points
  // We need to know what points we need to send which processors
  // One processor will receive many points from many processors
  // One point may go to different processors
  ProcessorToPointVec outgoing_points;
  extractOutgoingPoints(i, outgoing_points);

  if (_from_var_names.size())
    prepareEvaluationOfInterpValues(i);
  else
    prepareEvaluationOfInterpValues(-1);

  // Fill values and app ids for incoming points
  // We are responsible to compute values for these incoming points
  auto gather_functor =
      [this](processor_id_type /*pid*/,
             const std::vector<std::pair<Point, unsigned int>> & incoming_locations,
             std::vector<std::pair<Real, Real>> & outgoing_vals)
  {
    outgoing_vals.resize(
        incoming_locations.size(),
        {GeneralFieldTransfer::BetterOutOfMeshValue, GeneralFieldTransfer::BetterOutOfMeshValue});
    // Evaluate interpolation values for these incoming points
    evaluateInterpValues(incoming_locations, outgoing_vals);
  };

  DofobjectToInterpValVec dofobject_to_valsvec(_to_problems.size());
  InterpCaches interp_caches(_to_problems.size(), getMaxToProblemsBBoxDimensions());
  InterpCaches distance_caches(_to_problems.size(), getMaxToProblemsBBoxDimensions());

  // Copy data out to incoming_vals_ids
  auto action_functor = [this, &i, &dofobject_to_valsvec, &interp_caches, &distance_caches](
                            processor_id_type pid,
                            const std::vector<std::pair<Point, unsigned int>> & my_outgoing_points,
                            const std::vector<std::pair<Real, Real>> & incoming_vals)
  {
    auto & pointInfoVec = _processor_to_pointInfoVec[pid];

    // Cache interpolation values for each dof object / points
    cacheIncomingInterpVals(pid,
                            i,
                            pointInfoVec,
                            my_outgoing_points,
                            incoming_vals,
                            dofobject_to_valsvec,
                            interp_caches,
                            distance_caches);
  };

  // We assume incoming_vals_ids is ordered in the same way as outgoing_points
  // Hopefully, pull_parallel_vector_data will not mess up this
  const std::pair<Real, Real> * ex = nullptr;
  libMesh::Parallel::pull_parallel_vector_data(
      comm(), outgoing_points, gather_functor, action_functor, ex);

  // Check for conflicts and overlaps from the maps that were built during the transfer
  if (_search_value_conflicts)
    outputValueConflicts(i, dofobject_to_valsvec, distance_caches);

  // Set cached values into solution vector
  setSolutionVectorValues(i, dofobject_to_valsvec, interp_caches);
}

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 460 of file MultiAppTransfer.C.

Referenced by MultiAppTransfer::getFromBoundingBoxes(), and 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 89 of file MooseBase.h.

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

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

typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

Returns

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

Definition at line 54 of file MooseBase.C.

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

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

uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns

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

Definition at line 66 of file MooseBase.C.

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

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

uniqueParameterName()

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

inherited

Returns

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

Definition at line 60 of file MooseBase.C.

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

validParams()

InputParameters MultiAppGeneralFieldTransfer::validParams ( )

static

Definition at line 39 of file MultiAppGeneralFieldTransfer.C.

Referenced by MultiAppGeneralFieldShapeEvaluationTransfer::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), and MultiAppGeneralFieldNearestLocationTransfer::validParams().

{
  InputParameters params = MultiAppConservativeTransfer::validParams();
  // Expansion default to make a node in the target mesh overlapping with a node in the origin
  // mesh always register as being inside the origin application bounding box. The contains_point
  // bounding box checks uses exact comparisons
  params.addRangeCheckedParam<Real>("bbox_factor",
                                    1.00000001,
                                    "bbox_factor>0",
                                    "Factor to inflate or deflate the source app bounding boxes");
  params.addRangeCheckedParam<std::vector<Real>>(
      "fixed_bounding_box_size",
      "fixed_bounding_box_size >= 0",
      "Override source app bounding box size(s) for searches. App bounding boxes will still be  "
      "centered on the same coordinates. Only non-zero components passed will override.");
  params.addParam<Real>(
      "extrapolation_constant",
      0,
      "Constant to use when no source app can provide a valid value for a target location.");

  // Block restrictions
  params.addParam<std::vector<SubdomainName>>(
      "from_blocks",
      "Subdomain restriction to transfer from (defaults to all the origin app domain)");
  params.addParam<std::vector<SubdomainName>>(
      "to_blocks", "Subdomain restriction to transfer to, (defaults to all the target app domain)");

  // Boundary restrictions
  params.addParam<std::vector<BoundaryName>>(
      "from_boundaries",
      "The boundary we are transferring from (if not specified, whole domain is used).");
  params.addParam<std::vector<BoundaryName>>(
      "to_boundaries",
      "The boundary we are transferring to (if not specified, whole domain is used).");
  MooseEnum nodes_or_sides("nodes sides", "sides");
  params.addParam<MooseEnum>("elemental_boundary_restriction",
                             nodes_or_sides,
                             "Whether elemental variable boundary restriction is considered by "
                             "element side or element nodes");

  // Mesh division restriction
  params.addParam<MeshDivisionName>("from_mesh_division",
                                    "Mesh division object on the origin application");
  params.addParam<MeshDivisionName>("to_mesh_division",
                                    "Mesh division object on the target application");
  MooseEnum mesh_division_uses("spatial_restriction matching_division matching_subapp_index none",
                               "none");
  params.addParam<MooseEnum>("from_mesh_division_usage",
                             mesh_division_uses,
                             "How to use the source mesh division in the transfer. See object "
                             "documentation for description of each option");
  params.addParam<MooseEnum>("to_mesh_division_usage",
                             mesh_division_uses,
                             "How to use the target mesh division in the transfer. See object "
                             "documentation for description of each option");

  // Array and vector variables
  params.addParam<std::vector<unsigned int>>("source_variable_components",
                                             std::vector<unsigned int>(),
                                             "The source array or vector variable component(s).");
  params.addParam<std::vector<unsigned int>>("target_variable_components",
                                             std::vector<unsigned int>(),
                                             "The target array or vector variable component(s).");

  // Search options
  params.addParam<bool>(
      "greedy_search",
      false,
      "Whether or not to send a point to all the domains. If true, all the processors will be "
      "checked for a given point."
      "The code will be slow if this flag is on but it will give a better solution.");
  params.addParam<bool>(
      "error_on_miss",
      true,
      "Whether or not to error in the case that a target point is not found in the source domain.");
  params.addParam<bool>("use_bounding_boxes",
                        true,
                        "When set to false, bounding boxes will not be used to restrict the source "
                        "of the transfer. Either source applications must be set using the "
                        "from_mesh_division parameter, or a greedy search must be used.");
  params.addParam<bool>(
      "use_nearest_app",
      false,
      "When True, transfers from a child application will work by finding the nearest (using "
      "the `position` + mesh centroid) sub-app and query that app for the value to transfer.");
  params.addParam<PositionsName>(
      "use_nearest_position",
      "Name of the the Positions object (in main app) such that transfers to/from a child "
      "application will work by finding the nearest position to a target and query only the "
      "app / points closer to this position than to any other position for the value to transfer.");
  params.addParam<bool>(
      "from_app_must_contain_point",
      false,
      "Wether on not the origin mesh must contain the point to evaluate data at. If false, this "
      "allows for interpolation between origin app meshes. Origin app bounding boxes are still "
      "considered so you may want to increase them with 'fixed_bounding_box_size'");
  params.addParam<bool>("search_value_conflicts",
                        false,
                        "Whether to look for potential conflicts between two valid and different "
                        "source values for any target point");
  params.addParam<unsigned int>(
      "value_conflicts_output",
      10,
      "Maximum number of conflicts to output if value-conflicts, from equidistant sources to a "
      "given transfer target location, search is turned on");

  params.addParamNamesToGroup(
      "to_blocks from_blocks to_boundaries from_boundaries elemental_boundary_restriction "
      "from_mesh_division from_mesh_division_usage to_mesh_division to_mesh_division_usage",
      "Transfer spatial restriction");
  params.addParamNamesToGroup(
      "greedy_search use_bounding_boxes use_nearest_app use_nearest_position "
      "search_value_conflicts",
      "Search algorithm");
  params.addParamNamesToGroup("error_on_miss from_app_must_contain_point extrapolation_constant",
                              "Extrapolation behavior");
  params.addParamNamesToGroup("bbox_factor fixed_bounding_box_size", "Source app bounding box");
  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 197 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& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

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

_already_output_search_value_conflicts

bool MultiAppGeneralFieldTransfer::_already_output_search_value_conflicts

protected

Whether we already output the search value conflicts.

Definition at line 272 of file MultiAppGeneralFieldTransfer.h.

Referenced by postExecute(), and prepareToTransfer().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 353 of file MooseBase.h.

_bbox_factor

Real MultiAppGeneralFieldTransfer::_bbox_factor

private

How much we should relax bounding boxes.

Definition at line 348 of file MultiAppGeneralFieldTransfer.h.

Referenced by prepareToTransfer().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

_current_direction

MooseEnum Transfer::_current_direction

protectedinherited

Definition at line 106 of file Transfer.h.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), Transfer::currentDirection(), MultiAppCloneReporterTransfer::execute(), MultiAppReporterTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppUserObjectTransfer::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().

_default_extrapolation_value

const Real MultiAppGeneralFieldTransfer::_default_extrapolation_value

private

Value to use when no received data is valid for a target location.

Definition at line 345 of file MultiAppGeneralFieldTransfer.h.

Referenced by setSolutionVectorValues().

_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 161 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), MultiAppUserObjectTransfer::execute(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), MultiAppUserObjectTransfer::findSubAppToTransferFrom(), getAppInfo(), MultiAppTransfer::getAppInfo(), getRestrictedFromBoundingBoxes(), initialSetup(), 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 163 of file MultiAppTransfer.h.

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

_elemental_boundary_restriction_on_sides

const bool MultiAppGeneralFieldTransfer::_elemental_boundary_restriction_on_sides

protected

Whether elemental variable boundary restriction is considered by element side or element nodes.

Definition at line 254 of file MultiAppGeneralFieldTransfer.h.

_enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 50 of file MooseObject.h.

Referenced by MooseObject::enabled().

_error_on_miss

bool MultiAppGeneralFieldTransfer::_error_on_miss

private

Error out when some points can not be located.

Definition at line 342 of file MultiAppGeneralFieldTransfer.h.

Referenced by locatePointReceivers(), and setSolutionVectorValues().

_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(), FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), 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& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

_fe_problem

FEProblemBase& Transfer::_fe_problem

protectedinherited

Definition at line 97 of file Transfer.h.

Referenced by acceptPointInOriginMesh(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), closestToPosition(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), MultiAppCloneReporterTransfer::initialSetup(), locatePointReceivers(), MultiAppGeneralFieldTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), and MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer().

_fixed_bbox_size

std::vector<Real> MultiAppGeneralFieldTransfer::_fixed_bbox_size

private

Set the bounding box sizes manually.

Definition at line 351 of file MultiAppGeneralFieldTransfer.h.

Referenced by getRestrictedFromBoundingBoxes().

_from_bboxes

std::vector<BoundingBox> MultiAppGeneralFieldTransfer::_from_bboxes

private

Bounding boxes for all source applications.

The indexing of this vector is similar to 'processor_id * n_local_subapps + i_local_subapp', except the number of local subapps can be different on each processor. Use the _from_per_proc vector to find the start/end index for a given processor. See MultiAppGeneralFieldTransfer::locatePointReceivers() for an example

Definition at line 360 of file MultiAppGeneralFieldTransfer.h.

Referenced by extractLocalFromBoundingBoxes(), locatePointReceivers(), and prepareToTransfer().

_from_blocks

std::set<SubdomainID> MultiAppGeneralFieldTransfer::_from_blocks

protected

Origin block(s) restriction.

Definition at line 222 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), getRestrictedFromBoundingBoxes(), and initialSetup().

_from_boundaries

std::set<BoundaryID> MultiAppGeneralFieldTransfer::_from_boundaries

protected

Origin boundary(ies) restriction.

Definition at line 231 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), getRestrictedFromBoundingBoxes(), and initialSetup().

_from_es

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

protectedinherited

Definition at line 148 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 205 of file MultiAppTransfer.h.

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

_from_mesh_division_behavior

const MooseEnum& MultiAppGeneralFieldTransfer::_from_mesh_division_behavior

protected

How to use the origin mesh divisions to restrict the transfer.

Definition at line 240 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointMeshDivision(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), cacheOutgoingPointInfo(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), and MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer().

_from_mesh_divisions

std::vector<const MeshDivision *> MultiAppGeneralFieldTransfer::_from_mesh_divisions

protected

Division of the origin mesh.

Definition at line 234 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), acceptPointMeshDivision(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), initialSetup(), and MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer().

_from_meshes

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

protectedinherited

Definition at line 150 of file MultiAppTransfer.h.

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

_from_point_locators

std::vector<std::unique_ptr<libMesh::PointLocatorBase> > MultiAppGeneralFieldTransfer::_from_point_locators

protected

Point locators, useful to examine point location with regards to domain restriction.

Definition at line 257 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), and getAppInfo().

_from_positions

std::vector<Point> MultiAppTransfer::_from_positions

protectedinherited

Definition at line 152 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 146 of file MultiAppTransfer.h.

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

_from_transforms

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

protectedinherited

Definition at line 154 of file MultiAppTransfer.h.

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

_from_var_components

const std::vector<unsigned int> MultiAppGeneralFieldTransfer::_from_var_components

protected

Origin array/vector variable components.

Definition at line 195 of file MultiAppGeneralFieldTransfer.h.

Referenced by getFromVarName(), initialSetup(), and MultiAppGeneralFieldTransfer().

_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(), getFromVarName(), MultiAppConservativeTransfer::getFromVarNames(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), initialSetup(), MultiAppGeneralFieldTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), outputValueConflicts(), MultiAppShapeEvaluationTransfer::transferVariable(), and transferVariable().

_froms_per_proc

std::vector<unsigned int> MultiAppGeneralFieldTransfer::_froms_per_proc

private

Number of source/from applications per processor. This vector is indexed by processor id.

Definition at line 354 of file MultiAppGeneralFieldTransfer.h.

Referenced by extractLocalFromBoundingBoxes(), locatePointReceivers(), and prepareToTransfer().

_global_app_start_per_proc

std::vector<unsigned int> MultiAppGeneralFieldTransfer::_global_app_start_per_proc

protected

First app each processor owns, indexed by processor If no app on the processor, will have a -1 for the app start instead.

Definition at line 261 of file MultiAppGeneralFieldTransfer.h.

Referenced by locatePointReceivers(), and prepareToTransfer().

_greedy_search

bool MultiAppGeneralFieldTransfer::_greedy_search

protected

Whether or not a greedy strategy will be used If true, all the partitions will be checked for a given outgoing point.

Definition at line 266 of file MultiAppGeneralFieldTransfer.h.

Referenced by locatePointReceivers().

_local_conflicts

std::vector<std::tuple<unsigned int, dof_id_type, Point, Real> > MultiAppGeneralFieldTransfer::_local_conflicts

private

Keeps track of all local equidistant points to requested points, creating an indetermination in which values should be sent for that request We keep the origin problem ID, the dof ID, the point, and the distance origin-target If using nearest-positions the origin problem ID is not set.

Definition at line 369 of file MultiAppGeneralFieldTransfer.h.

Referenced by examineLocalValueConflicts(), outputValueConflicts(), and registerConflict().

_multi_app

std::shared_ptr<MultiApp> MultiAppTransfer::_multi_app

protectedinherited

Deprecated class attribute for compatibility with the apps.

Definition at line 143 of file MultiAppTransfer.h.

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

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 359 of file MooseBase.h.

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

_nearest_positions_obj

const Positions* MultiAppGeneralFieldTransfer::_nearest_positions_obj

protected

Definition at line 215 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), closestToPosition(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), examineLocalValueConflicts(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), MultiAppGeneralFieldNearestLocationTransfer::getPointInLocalSourceFrame(), locatePointReceivers(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), and outputValueConflicts().

_pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 362 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

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

_processor_to_pointInfoVec

ProcessorToPointInfoVec MultiAppGeneralFieldTransfer::_processor_to_pointInfoVec

private

A map from processor to pointInfo vector.

Definition at line 363 of file MultiAppGeneralFieldTransfer.h.

Referenced by cacheOutgoingPointInfo(), extractOutgoingPoints(), and transferVariable().

_received_conflicts

std::vector<std::tuple<unsigned int, dof_id_type, Point, Real> > MultiAppGeneralFieldTransfer::_received_conflicts

private

Keeps track of all received conflicts.

Multiple problems (different subapps for example) are sending values for a target point that do not match and are equally valid/distant We keep the target problem ID, the point/dof ID, the point, and the origin-target distance. The distance indicates whether a potential conflict ended up materializing

Definition at line 375 of file MultiAppGeneralFieldTransfer.h.

Referenced by examineReceivedValueConflicts(), outputValueConflicts(), and registerConflict().

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

_search_value_conflicts

bool MultiAppGeneralFieldTransfer::_search_value_conflicts

protected

Whether to look for conflicts between origin points, multiple valid values for a target point.

Definition at line 269 of file MultiAppGeneralFieldTransfer.h.

Referenced by cacheIncomingInterpVals(), closestToPosition(), detectConflict(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), locatePointReceivers(), postExecute(), prepareToTransfer(), and transferVariable().

_search_value_conflicts_max_log

const unsigned int MultiAppGeneralFieldTransfer::_search_value_conflicts_max_log

protected

How many conflicts are output to console.

Definition at line 275 of file MultiAppGeneralFieldTransfer.h.

Referenced by outputValueConflicts().

_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 158 of file MultiAppTransfer.h.

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

_source_app_must_contain_point

bool MultiAppGeneralFieldTransfer::_source_app_must_contain_point

protected

Whether the source app mesh must actually contain the points for them to be considered or whether the bounding box is enough.

If false, we can interpolate between apps

Definition at line 219 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldTransfer(), and MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer().

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

std::set<SubdomainID> MultiAppGeneralFieldTransfer::_to_blocks

protected

Target block(s) restriction.

Definition at line 225 of file MultiAppGeneralFieldTransfer.h.

Referenced by extractOutgoingPoints(), initialSetup(), and setSolutionVectorValues().

_to_boundaries

std::set<BoundaryID> MultiAppGeneralFieldTransfer::_to_boundaries

protected

Target boundary(ies) restriction.

Definition at line 228 of file MultiAppGeneralFieldTransfer.h.

Referenced by extractOutgoingPoints(), and initialSetup().

_to_es

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

protectedinherited

Definition at line 147 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 203 of file MultiAppTransfer.h.

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

_to_mesh_division_behavior

const MooseEnum& MultiAppGeneralFieldTransfer::_to_mesh_division_behavior

protected

How to use the target mesh divisions to restrict the transfer.

Definition at line 243 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointMeshDivision(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), cacheOutgoingPointInfo(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), initialSetup(), locatePointReceivers(), and MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer().

_to_mesh_divisions

std::vector<const MeshDivision *> MultiAppGeneralFieldTransfer::_to_mesh_divisions

protected

Division of the target mesh.

Definition at line 237 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), cacheOutgoingPointInfo(), extractOutgoingPoints(), initialSetup(), and locatePointReceivers().

_to_meshes

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

protectedinherited

Definition at line 149 of file MultiAppTransfer.h.

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

_to_positions

std::vector<Point> MultiAppTransfer::_to_positions

protectedinherited

Definition at line 151 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 145 of file MultiAppTransfer.h.

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

_to_transforms

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

protectedinherited

Definition at line 153 of file MultiAppTransfer.h.

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

_to_var_components

const std::vector<unsigned int> MultiAppGeneralFieldTransfer::_to_var_components

protected

Target array/vector variable components.

Definition at line 198 of file MultiAppGeneralFieldTransfer.h.

Referenced by getToVarName(), initialSetup(), and MultiAppGeneralFieldTransfer().

_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(), MultiAppUserObjectTransfer::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 getToVarName(), MultiAppConservativeTransfer::getToVarNames(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), initialSetup(), MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

_to_variables

std::vector<MooseVariableFieldBase *> MultiAppGeneralFieldTransfer::_to_variables

private

The target variables.

Definition at line 303 of file MultiAppGeneralFieldTransfer.h.

Referenced by cacheIncomingInterpVals(), examineLocalValueConflicts(), examineReceivedValueConflicts(), extractOutgoingPoints(), initialSetup(), and setSolutionVectorValues().

_type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 356 of file MooseBase.h.

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

_use_bounding_boxes

const bool MultiAppGeneralFieldTransfer::_use_bounding_boxes

protected

Whether to use bounding boxes to determine the applications that may receive point requests then send value data, and at other various checks.

Definition at line 202 of file MultiAppGeneralFieldTransfer.h.

Referenced by acceptPointInOriginMesh(), locatePointReceivers(), MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::prepareEvaluationOfInterpValues(), and MultiAppGeneralFieldUserObjectTransfer::prepareEvaluationOfInterpValues().

_use_nearest_app

const bool MultiAppGeneralFieldTransfer::_use_nearest_app

protected

Whether to keep track of the distance from the requested point to the app position.

Definition at line 205 of file MultiAppGeneralFieldTransfer.h.

Referenced by MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), cacheIncomingInterpVals(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), MultiAppGeneralFieldNearestLocationTransfer::getAppIndex(), MultiAppGeneralFieldNearestLocationTransfer::getNumAppsPerTree(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), locatePointReceivers(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), and MultiAppGeneralFieldTransfer().

_var_size

unsigned int MultiAppGeneralFieldTransfer::_var_size

private

The number of variables to transfer.

Definition at line 339 of file MultiAppGeneralFieldTransfer.h.

Referenced by execute(), MultiAppGeneralFieldTransfer(), and transferVariable().

app_param

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

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

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

moose_base_param

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

staticinherited

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

Definition at line 61 of file MooseBase.h.

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

name_param

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

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

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

OutOfMeshValue

const Number Transfer::OutOfMeshValue = -999999

staticinherited

Definition at line 113 of file Transfer.h.

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

type_param

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

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

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

unique_name_param

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

staticinherited

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

Definition at line 57 of file MooseBase.h.

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

---

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

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