https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
MultiAppUserObjectTransfer Class Reference

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

#include <MultiAppUserObjectTransfer.h>

Inheritance diagram for MultiAppUserObjectTransfer:
[legend]

Public Types

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

Public Member Functions

 MultiAppUserObjectTransfer (const InputParameters &parameters)
 
virtual void execute () override
 Execute the transfer.
 
virtual void initialSetup () override
 Method called at the beginning of the simulation for checking integrity or doing one-time setup.
 
virtual void postExecute ()
 Add some extra work if necessary after execute().
 
void variableIntegrityCheck (const AuxVariableName &var_name, bool is_from_multiapp) const
 Utility to verify that the variable in the destination system exists.
 
const std::shared_ptr< MultiApp > getMultiApp () const
 Use this getter to obtain the MultiApp for transfers with a single direction.
 
const std::shared_ptr< MultiApp > getFromMultiApp () const
 Get the MultiApp to transfer data from.
 
const std::shared_ptr< MultiApp > getToMultiApp () const
 Get the MultiApp to transfer data to.
 
std::string getFromName () const
 Get the name of thing being transferred from.
 
std::string getToName () const
 Get the name of thing being transferred to.
 
bool hasFromMultiApp () const
 Whether the transfer owns a non-null from_multi_app.
 
bool hasToMultiApp () const
 Whether the transfer owns a non-null to_multi_app.
 
virtual void getAppInfo ()
 This method will fill information into the convenience member variables (_to_problems, _from_meshes, etc.)
 
const MultiMooseEnum & directions ()
 The directions this Transfer should be executed on.
 
void setCurrentDirection (const int direction)
 Set this Transfer to be executed in a given direction.
 
virtual bool enabled () const
 Return the enabled status of the object.
 
std::shared_ptr< MooseObject > getSharedPtr ()
 Get another shared pointer to this object that has the same ownership group.
 
std::shared_ptr< const MooseObject > getSharedPtr () const
 
bool isKokkosObject () const
 Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.
 
MooseApp & getMooseApp () const
 Get the MooseApp this class is associated with.
 
const std::string & type () const
 Get the type of this class.
 
const std::string & name () const
 Get the name of the class.
 
std::string typeAndName () const
 Get the class's combined type and name; useful in error handling.
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 Get the parameters of the object.
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
template<typename T >
const T & getParam (const std::string &name) const
 Retrieve a parameter for the object.
 
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 Retrieve two parameters and provide pair of parameters for the object.
 
template<typename T >
const T * queryParam (const std::string &name) const
 Query a parameter for the object.
 
template<typename T >
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 Retrieve a renamed parameter for the object.
 
template<typename T >
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 Verifies that the requested parameter exists and is not NULL and returns it to the caller.
 
bool isParamValid (const std::string &name) const
 Test if the supplied parameter is valid.
 
bool isParamSetByUser (const std::string &name) const
 Test if the supplied parameter is set by a user, as opposed to not set or set to default.
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 Connect controllable parameter of this action with the controllable parameters of the objects added by this action.
 
template<typename... Args>
void paramError (const std::string &param, Args... args) const
 Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
 
template<typename... Args>
void paramWarning (const std::string &param, Args... args) const
 Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
 
template<typename... Args>
void paramWarning (const std::string &param, Args... args) const
 
template<typename... Args>
void paramInfo (const std::string &param, Args... args) const
 Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 Deprecated message prefix; the error type is no longer used.
 
template<typename... Args>
void mooseError (Args &&... args) const
 Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.
 
template<typename... Args>
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
template<typename... Args>
void mooseErrorNonPrefixed (Args &&... args) const
 Emits an error without the prefixing included in mooseError().
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 Emits a warning prefixed with object name and type.
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 Emits a warning without the prefixing included in mooseWarning().
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 Emits a deprecation warning prefixed with the object name and type, and a stack trace.
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
template<typename... Args>
void mooseDeprecatedNoTrace (Args &&... args) const
 Emits a deprecation warning prefixed with the object name and type, and no stack trace.
 
template<typename... Args>
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 External method for calling moose error with added object context.
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
std::string getDataFileName (const std::string &param) const
 Deprecated method.
 
std::string getDataFileNameByName (const std::string &relative_path) const
 Deprecated method.
 
std::string getDataFilePath (const std::string &relative_path) const
 Returns the path of a data file for a given relative file path.
 
virtual void timestepSetup ()
 Gets called at the beginning of the timestep before this object is asked to do its job.
 
virtual void jacobianSetup ()
 Gets called just before the Jacobian is computed and before this object is asked to do its job.
 
virtual void residualSetup ()
 Gets called just before the residual is computed and before this object is asked to do its job.
 
virtual void subdomainSetup ()
 Gets called when the subdomain changes (i.e.
 
virtual void customSetup (const ExecFlagType &)
 Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.
 
const ExecFlagEnum & getExecuteOnEnum () const
 Return the execute on MultiMooseEnum for this object.
 
PerfGraph & perfGraph ()
 Get the PerfGraph.
 
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.
 
static libMesh::System * find_sys (libMesh::EquationSystems &es, const std::string &var_name)
 Small helper function for finding the system containing the variable.
 
static std::string possibleDirections ()
 Used to construct InputParameters.
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 External method for calling moose error with added object context.
 

Public Attributes

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

Static Public Attributes

static const libMesh::Number OutOfMeshValue = -999999
 
static const std::string type_param = "_type"
 The name of the parameter that contains the object type.
 
static const std::string name_param = "_object_name"
 The name of the parameter that contains the object name.
 
static const std::string unique_name_param = "_unique_name"
 The name of the parameter that contains the unique object name.
 
static const std::string app_param = "_moose_app"
 The name of the parameter that contains the MooseApp.
 
static const std::string moose_base_param = "_moose_base"
 The name of the parameter that contains the moose system base.
 
static const std::string kokkos_object_param = "_kokkos_object"
 The name of the parameter that indicates an object is a Kokkos functor.
 

Protected Member Functions

bool blockRestricted () const
 
bool boundaryRestricted () const
 
bool hasBlocks (const Elem *elem) const
 Check that element 'elem' is part of the domain this transfer is restricted to.
 
bool hasBlocks (const MooseMesh *mesh, const Node *node) const
 Check that Node 'node' belongs to block this transfer is restricted to.
 
bool isBoundaryNode (const MooseMesh *mesh, const Node *node) const
 Check that the node belongs to boundary this transfer is restricted to.
 
bool isBoundaryElem (const MooseMesh *mesh, const Elem *elem) const
 Check that the element belongs to boundary this transfer is restricted to.
 
unsigned int findSubAppToTransferFrom (const Point &p)
 Gets the UserObject to transfer from when transferring from_multiapp.
 
virtual std::vector< VariableName > getFromVarNames () const override
 Virtual function defining variables to be transferred.
 
virtual std::vector< AuxVariableName > getToVarNames () const override
 Virtual function defining variables to transfer to.
 
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.
 
std::vector< unsigned int > getFromsPerProc ()
 Return the number of "from" domains that each processor owns.
 
libMesh::NumericVector< Real > & getTransferVector (unsigned int i_local, std::string var_name)
 If we are transferring to a multiapp, return the appropriate solution vector.
 
unsigned int getGlobalSourceAppIndex (unsigned int i_from) const
 Return the global app index from the local index in the "from-multiapp" transfer direction.
 
unsigned int getGlobalTargetAppIndex (unsigned int i_to) const
 Return the global app index from the local index in the "to-multiapp" transfer direction.
 
unsigned int getLocalSourceAppIndex (unsigned int i_from) const
 Return the local app index from the global index in the "from-multiapp" transfer direction.
 
virtual void checkSiblingsTransferSupported () const
 Whether the transfer supports siblings transfer.
 
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.
 
void errorIfObjectExecutesOnTransferInSourceApp (const std::string &object_name) const
 Error if executing this MooseObject on EXEC_TRANSFER in a source multiapp (from_multiapp, e.g.
 
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.
 
Point getPointInSourceAppFrame (const Point &p, unsigned int local_i_from, const std::string &phase) const
 Get the source app point from a point in the reference frame.
 
void checkMultiAppExecuteOn ()
 Helper method for checking the 'check_multiapp_execute_on' flag.
 
void checkVariable (const FEProblemBase &fe_problem, const VariableName &var_name, const std::string &param_name="") const
 Helper for checking a problem for a variable.
 
void extendBoundingBoxes (const Real factor, std::vector< libMesh::BoundingBox > &bboxes) const
 Extends bounding boxes to avoid missing points.
 
template<bool warning>
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 Set solution invalid mark for the given solution ID.
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 
template<typename T , typename... Args>
T & declareRestartableData (const std::string &data_name, Args &&... args)
 Declare a piece of data as "restartable" and initialize it.
 
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.
 
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.
 
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.
 
template<typename T , typename... Args>
T & declareRecoverableData (const std::string &data_name, Args &&... args)
 Declare a piece of data as "recoverable" and initialize it.
 
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".
 
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".
 
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.
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 Call to register a named section for timing.
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 Call to register a named section for timing.
 
std::string timedSectionName (const std::string &section_name) const
 
std::vector< libMesh::BoundingBox > getFromBoundingBoxes ()
 Return the bounding boxes of all the "from" domains, including all the domains not local to this processor.
 
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)
 
static void addBBoxFactorParam (InputParameters &params)
 Add the bounding box factor parameter to the supplied input parameters.
 
static void transformBoundingBox (libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)
 Transform a bounding box according to the transformations in the provided coordinate transformation object.
 

Protected Attributes

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

Private Member Functions

bool usesMooseAppCoordTransform () const override
 Whether this transfer handles non-translation-based transformations, e.g.
 
void adjustTransferredSolution (FEProblemBase *from_problem, PostprocessorName &from_postprocessor, FEProblemBase &to_problem, PostprocessorName &to_postprocessor)
 
void adjustTransferredSolutionNearestPoint (unsigned int i, FEProblemBase *from_problem, PostprocessorName &from_postprocessor, FEProblemBase &to_problem, PostprocessorName &to_postprocessor)
 
Point mapBackWithoutCollapsing (MultiAppCoordTransform &transform, const Point &p, const std::string &phase) const
 Shared implementation for getPointInSourceAppFrame / getPointInTargetAppFrame.
 
void getFromMultiAppInfo ()
 
void getToMultiAppInfo ()
 
RestartableDataValue & registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
 Helper function for actually registering the restartable data.
 
void registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
 Helper function for actually registering the restartable data.
 
template<typename T , typename... Args>
RestartableData< T > & declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
 Helper function for declaring restartable data.
 

Static Private Member Functions

static const hit::Node * getHitNode (const InputParameters &params)
 Internal method for getting a hit node (if available) given a set of parameters.
 
static std::string messagePrefix (const InputParameters &params, const bool hit_prefix)
 Internal method for getting the message prefix for an object (object type, name, etc).
 

Private Attributes

std::set< SubdomainID > _blk_ids
 Set of block ids this transfer is restricted to.
 
std::set< BoundaryID > _bnd_ids
 Set of the boundary ids.
 
bool _use_nearestpoint_pps
 Whether to use a nearest point UserObject to obtain the conservation factor.
 
bool _allow_skipped_adjustment
 Whether the adjustment may be skipped when the postprocessor values are 0 / of different signs.
 
std::shared_ptr< MultiApp > _from_multi_app
 The MultiApps this Transfer is transferring data to or from.
 
std::shared_ptr< MultiApp > _to_multi_app
 
std::unique_ptr< MooseAppCoordTransform > _from_moose_app_transform
 The moose coordinate transformation object describing rotations, scaling, and coordinate system of the from application.
 
std::unique_ptr< MooseAppCoordTransform > _to_moose_app_transform
 The moose coordinate transformation object describing rotations, scaling, and coordinate system of the to application.
 
const ParallelParamObject & _parent
 
const MooseBase & _si_moose_base
 The MooseBase that owns this interface.
 
const FEProblemBase * _si_problem
 A pointer to FEProblem base.
 
ExecFlagEnum _empty_execute_enum
 Empty ExecFlagEnum for the case when the "execute_on" parameter is not included.
 
const RestartableDataMapName _metaname
 Restartable metadata name.
 
std::string _restartable_name
 The name of the object.
 

Detailed Description

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

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

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

Definition at line 28 of file MultiAppUserObjectTransfer.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName
inherited

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

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

◆ DIRECTION

enum Transfer::DIRECTION
inherited
Enumerator
TO_MULTIAPP 
FROM_MULTIAPP 
BETWEEN_MULTIAPP 

Definition at line 68 of file Transfer.h.

69 {
70 TO_MULTIAPP,
71 FROM_MULTIAPP,
72 BETWEEN_MULTIAPP
73 };
Transfer::FROM_MULTIAPP
@ FROM_MULTIAPP
Definition Transfer.h:71
Transfer::TO_MULTIAPP
@ TO_MULTIAPP
Definition Transfer.h:70
Transfer::BETWEEN_MULTIAPP
@ BETWEEN_MULTIAPP
Definition Transfer.h:72

Constructor & Destructor Documentation

◆ MultiAppUserObjectTransfer()

MultiAppUserObjectTransfer::MultiAppUserObjectTransfer ( const InputParameters &  parameters)

Definition at line 82 of file MultiAppUserObjectTransfer.C.

83 : MultiAppConservativeTransfer(parameters),
84 _user_object_name(getParam<UserObjectName>("user_object")),
85 _all_parent_nodes_contained_in_sub_app(
86 isParamValid("all_master_nodes_contained_in_sub_app")
87 ? getParam<bool>("all_master_nodes_contained_in_sub_app")
88 : getParam<bool>("all_parent_nodes_contained_in_sub_app")),
89 _skip_bbox_check(getParam<bool>("skip_bounding_box_check")),
90 _nearest_sub_app(getParam<bool>("nearest_sub_app"))
91{
92 mooseDeprecated("MultiAppUserObjectTransfer is deprecated. Use "
93 "MultiAppGeneralFieldUserObjectTransfer instead and adapt the parameters");
94
95 // This transfer does not work with DistributedMesh
96 _fe_problem.mesh().errorIfDistributedMesh("MultiAppUserObjectTransfer");
97
98 if (_to_var_names.size() != 1)
99 paramError("variable", " Support single to-variable only ");
100
101 if (_from_var_names.size() > 0)
102 paramError("source_variable",
103 " You should not provide any source variables since the transfer takes values from "
104 "user objects ");
105
106 if (isParamValid("block") && isParamValid("boundary"))
107 mooseError(name(), ": Transfer can be either block- or boundary-restricted. Not both.");
108
109 if (isParamValid("to_multi_app") && isParamValid("from_multi_app") &&
110 getToMultiApp() != getFromMultiApp())
111 paramError("to_multi_app",
112 "Sibling multiapp transfer has not been implemented for this transfer.");
113}
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Definition MooseError.h:311
mooseDeprecated
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition MooseError.h:363
FEProblemBase::mesh
virtual MooseMesh & mesh() override
Definition FEProblemBase.h:181
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition MooseBase.h:131
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition MooseBase.h:103
MooseBase::paramError
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition MooseBase.h:457
MooseBase::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition MooseBase.h:406
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition MooseBase.h:199
MooseMesh::errorIfDistributedMesh
void errorIfDistributedMesh(std::string name) const
Generate a unified error message if the underlying libMesh mesh is a DistributedMesh.
Definition MooseMesh.C:3718
MultiAppConservativeTransfer
Transfers variables on possibly different meshes while conserving a user defined property (Postproces...
Definition MultiAppConservativeTransfer.h:19
MultiAppConservativeTransfer::_from_var_names
const std::vector< VariableName > _from_var_names
Name of variables transferring from.
Definition MultiAppConservativeTransfer.h:40
MultiAppConservativeTransfer::_to_var_names
const std::vector< AuxVariableName > _to_var_names
Name of variables transferring to.
Definition MultiAppConservativeTransfer.h:42
MultiAppTransfer::getToMultiApp
const std::shared_ptr< MultiApp > getToMultiApp() const
Get the MultiApp to transfer data to.
Definition MultiAppTransfer.h:77
MultiAppTransfer::getFromMultiApp
const std::shared_ptr< MultiApp > getFromMultiApp() const
Get the MultiApp to transfer data from.
Definition MultiAppTransfer.h:65
MultiAppUserObjectTransfer::_nearest_sub_app
const bool & _nearest_sub_app
Whether to utilize the nearest sub-app to transfer from.
Definition MultiAppUserObjectTransfer.h:100
MultiAppUserObjectTransfer::_all_parent_nodes_contained_in_sub_app
const bool _all_parent_nodes_contained_in_sub_app
Boolean variable to generate error if every parent app node cannot be mapped to a subApp during from_...
Definition MultiAppUserObjectTransfer.h:94
MultiAppUserObjectTransfer::_skip_bbox_check
const bool _skip_bbox_check
whether to check the bounding box check or not
Definition MultiAppUserObjectTransfer.h:97
Transfer::_fe_problem
FEProblemBase & _fe_problem
Definition Transfer.h:97

Member Function Documentation

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

60{
61 params.addRangeCheckedParam<Real>(
62 "bbox_factor",
63 1 + TOLERANCE,
64 "bbox_factor>0",
65 "Multiply bounding box width (in all directions) by the prescribed factor. Values less than "
66 "1 will shrink the bounding box; values greater than 1 will enlarge the bounding box. It is "
67 "generally not advised to ever shrink the bounding box. On the other hand it may be helpful "
68 "to enlarge the bounding box. Larger bounding boxes will lead to more accurate determination "
69 "of the closest node/element with the tradeoff of more communication.");
70}
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
Definition InputParameters.h:1947
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

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

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

74{
75 params.addParam<bool>(
76 "skip_coordinate_collapsing",
77 true,
78 "Whether to skip coordinate collapsing (translation and rotation are still performed, only "
79 "XYZ, RZ etc collapsing is skipped) when performing mapping and inverse "
80 "mapping coordinate transformation operations. This parameter should only "
81 "be set by users who really know what they're doing.");
82 params.addParamNamesToGroup("skip_coordinate_collapsing", "Advanced");
83}
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...
Definition InputParameters.C:1027
InputParameters::addParam
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object.
Definition InputParameters.h:1832

Referenced by MultiAppTransfer::validParams().

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

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

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

◆ adjustTransferredSolution()

void MultiAppConservativeTransfer::adjustTransferredSolution ( FEProblemBase *  from_problem,
PostprocessorName &  from_postprocessor,
FEProblemBase &  to_problem,
PostprocessorName &  to_postprocessor 
)
privateinherited

Definition at line 398 of file MultiAppConservativeTransfer.C.

402{
403 PostprocessorValue from_adjuster = 0;
404 if (from_problem)
405 from_adjuster = from_problem->getPostprocessorValueByName(from_postprocessor);
406 else
407 from_adjuster = 0;
408
409 /* Everyone on the parent side should know this value; use it to scale the solution */
410 if (_current_direction == FROM_MULTIAPP)
411 {
412 /* In this case, only one subapp has value, and other subapps' must be zero.
413 * We should see the maximum value.
414 */
415 PostprocessorValue from_adjuster_tmp = from_adjuster;
416 comm().max(from_adjuster);
417
418 /* We may have a negative value, and let us try it again */
419 if (MooseUtils::absoluteFuzzyLessEqual(from_adjuster, 0.))
420 {
421 comm().min(from_adjuster_tmp);
422 from_adjuster = from_adjuster_tmp;
423 }
424 }
425
426 // Compute to-postprocessor to have the adjuster
427 to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
428
429 // Now we should have the right adjuster based on the transferred solution
430 const auto to_adjuster = to_problem.getPostprocessorValueByName(to_postprocessor);
431
432 // decide if the adjustment should be performed
433 if (!performAdjustment(from_adjuster, to_adjuster))
434 return;
435
436 auto & to_var = to_problem.getVariable(
437 0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
438 auto & to_sys = to_var.sys().system();
439 auto var_num = to_sys.variable_number(_to_var_name);
440 auto sys_num = to_sys.number();
441 auto * pps =
442 dynamic_cast<const BlockRestrictable *>(&(to_problem.getUserObjectBase(to_postprocessor)));
443 auto & to_solution = to_var.sys().solution();
444 auto & to_mesh = to_problem.mesh().getMesh();
445 auto & moose_mesh = to_problem.mesh();
446 bool is_nodal = to_sys.variable_type(var_num).family == LAGRANGE;
447 if (is_nodal)
448 {
449 for (const auto & node : to_mesh.local_node_ptr_range())
450 {
451 // Skip this node if the variable has no dofs at it.
452 if (node->n_dofs(sys_num, var_num) < 1)
453 continue;
454
455 bool scale_current_node = false;
456 /* If we care about block IDs */
457 if (pps)
458 {
459 auto & blockids = pps->blockIDs();
460 auto & node_to_elem_map = moose_mesh.nodeToElemMap();
461 auto neighbor_elements = node_to_elem_map.find(node->id());
462 for (auto element : neighbor_elements->second)
463 {
464 auto & elem = to_mesh.elem_ref(element);
465 if (blockids.find(elem.subdomain_id()) != blockids.end())
466 {
467 scale_current_node = true;
468 break;
469 }
470 }
471 }
472 else
473 {
474 scale_current_node = true;
475 }
476 /* Need to scale this node */
477 if (scale_current_node)
478 {
479 dof_id_type dof = node->dof_number(sys_num, var_num, 0);
480 to_solution.set(dof, (from_adjuster / to_adjuster) * to_solution(dof));
481 }
482 }
483 }
484 else
485 {
486 for (auto & elem : as_range(to_mesh.local_elements_begin(), to_mesh.local_elements_end()))
487 {
488 // Skip this element if the variable has no dofs at it.
489 if (elem->n_dofs(sys_num, var_num) < 1)
490 continue;
491
492 bool scale_current_element = false;
493 if (pps)
494 {
495 auto & blockids = pps->blockIDs();
496 if (blockids.find(elem->subdomain_id()) != blockids.end())
497 {
498 scale_current_element = true;
499 }
500 }
501 else
502 {
503 scale_current_element = true;
504 }
505 if (scale_current_element)
506 {
507 unsigned int n_comp = elem->n_comp(sys_num, var_num);
508
509 for (unsigned int offset = 0; offset < n_comp; offset++)
510 {
511 dof_id_type dof = elem->dof_number(sys_num, var_num, offset);
512 to_solution.set(dof, (from_adjuster / to_adjuster) * to_solution(dof));
513 }
514 }
515 }
516 }
517
518 to_solution.close();
519 to_sys.update();
520
521 // Compute again so that the post-processor has the value with the updated solution
522 to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
523}
PostprocessorValue
Real PostprocessorValue
various MOOSE typedefs
Definition MooseTypes.h:230
EXEC_TRANSFER
const ExecFlagType EXEC_TRANSFER
Definition Moose.C:57
BlockRestrictable
An interface that restricts an object to subdomains via the 'blocks' input parameter.
Definition BlockRestrictable.h:69
FEProblemBase::getPostprocessorValueByName
const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName &name, std::size_t t_index=0) const
Get a read-only reference to the value associated with a Postprocessor that exists.
Definition FEProblemBase.C:4896
FEProblemBase::computeUserObjectByName
virtual void computeUserObjectByName(const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
Compute an user object with the given name.
Definition FEProblemBase.C:5313
FEProblemBase::getVariable
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
Definition FEProblemBase.C:6256
FEProblemBase::getUserObjectBase
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
Definition FEProblemBase.C:4746
MooseMesh::getMesh
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition MooseMesh.C:3549
MooseVariableBase::sys
SystemBase & sys()
Get the system this variable is part of.
Definition MooseVariableBase.h:70
MultiAppConservativeTransfer::performAdjustment
bool performAdjustment(const PostprocessorValue &from, const PostprocessorValue &to) const
Definition MultiAppConservativeTransfer.C:526
SystemBase::system
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
libMesh::Parallel::Communicator::max
void max(const T &r, T &o, Request &req) const
libMesh::Parallel::Communicator::min
void min(const T &r, T &o, Request &req) const
Transfer::_current_direction
MooseEnum _current_direction
Definition Transfer.h:106
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
libMesh::System::variable_number
unsigned int variable_number(std::string_view var) const
Moose::VAR_FIELD_STANDARD
@ VAR_FIELD_STANDARD
Definition MooseTypes.h:777
Moose::POST_AUX
@ POST_AUX
Definition MooseTypes.h:761
Moose::VAR_ANY
@ VAR_ANY
Definition MooseTypes.h:772
libMesh::as_range
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
libMesh::dof_id_type
uint8_t dof_id_type

Referenced by MultiAppConservativeTransfer::postExecute().

◆ adjustTransferredSolutionNearestPoint()

void MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint ( unsigned int  i,
FEProblemBase *  from_problem,
PostprocessorName &  from_postprocessor,
FEProblemBase &  to_problem,
PostprocessorName &  to_postprocessor 
)
privateinherited

Definition at line 280 of file MultiAppConservativeTransfer.C.

286{
287 PostprocessorValue from_adjuster = 0;
288 if (from_problem && _current_direction == FROM_MULTIAPP)
289 from_adjuster = from_problem->getPostprocessorValueByName(from_postprocessor);
290 else
291 from_adjuster = 0;
292
293 /* Everyone on the parent application side should know this value; use it to scale the solution */
294 if (_current_direction == FROM_MULTIAPP)
295 {
296 /* In this case, only one subapp has value, and other subapps' must be zero.
297 * We should see the maximum value.
298 */
299 PostprocessorValue from_adjuster_tmp = from_adjuster;
300 comm().max(from_adjuster);
301
302 /* We may have a negative value */
303 if (MooseUtils::absoluteFuzzyLessEqual(from_adjuster, 0.))
304 {
305 comm().min(from_adjuster_tmp);
306 from_adjuster = from_adjuster_tmp;
307 }
308 }
309
310 PostprocessorValue to_adjuster = 0;
311 // Compute to-postprocessor to have the adjuster
312 if (_current_direction == TO_MULTIAPP)
313 {
314 to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
315 to_adjuster = to_problem.getPostprocessorValueByName(to_postprocessor);
316 }
317
318 auto & to_var = to_problem.getVariable(
319 0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
320 auto & to_sys = to_var.sys().system();
321 auto var_num = to_sys.variable_number(_to_var_name);
322 auto sys_num = to_sys.number();
323 auto & pps = static_cast<const NearestPointIntegralVariablePostprocessor &>(
324 _current_direction == FROM_MULTIAPP ? (to_problem.getUserObjectBase(to_postprocessor))
325 : (from_problem->getUserObjectBase(from_postprocessor)));
326 auto & to_solution = to_var.sys().solution();
327 auto & to_mesh = to_problem.mesh().getMesh();
328 bool is_nodal = to_sys.variable_type(var_num).family == LAGRANGE;
329 if (is_nodal)
330 {
331 for (const auto & node : to_mesh.local_node_ptr_range())
332 {
333 // Skip this node if the variable has no dofs at it.
334 if (node->n_dofs(sys_num, var_num) < 1)
335 continue;
336
337 Real scale = 1;
338 if (_current_direction == FROM_MULTIAPP)
339 {
340 auto ii = pps.nearestPointIndex(*node);
341 if (ii != i || !performAdjustment(from_adjuster, pps.userObjectValue(i)))
342 continue;
343
344 scale = from_adjuster / pps.userObjectValue(i);
345 }
346 else
347 {
348 if (!performAdjustment(pps.userObjectValue(i), to_adjuster))
349 continue;
350
351 scale = pps.userObjectValue(i) / to_adjuster;
352 }
353
354 /* Need to scale this node */
355 dof_id_type dof = node->dof_number(sys_num, var_num, 0);
356 to_solution.set(dof, scale * to_solution(dof));
357 }
358 }
359 else
360 {
361 for (auto & elem : as_range(to_mesh.local_elements_begin(), to_mesh.local_elements_end()))
362 {
363 // Skip this element if the variable has no dofs at it.
364 if (elem->n_dofs(sys_num, var_num) < 1)
365 continue;
366
367 Real scale = 1;
368 if (_current_direction == FROM_MULTIAPP)
369 {
370 unsigned int ii = pps.nearestPointIndex(elem->vertex_average());
371 if (ii != i || !performAdjustment(from_adjuster, pps.userObjectValue(i)))
372 continue;
373
374 scale = from_adjuster / pps.userObjectValue(i);
375 }
376 else
377 {
378 if (!performAdjustment(pps.userObjectValue(i), to_adjuster))
379 continue;
380
381 scale = pps.userObjectValue(i) / to_adjuster;
382 }
383
384 dof_id_type dof = elem->dof_number(sys_num, var_num, 0);
385 to_solution.set(dof, scale * to_solution(dof));
386 }
387 }
388
389 to_solution.close();
390 to_sys.update();
391
392 // Compute the to-postprocessor again so that it has the right value with the updated solution
393 if (_current_direction == TO_MULTIAPP)
394 to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
395}
scale
Real scale
Definition MortarUtils.C:62
NearestPointIntegralVariablePostprocessor
Given a list of points this object computes the variable integral closest to each one of those points...
Definition NearestPointIntegralVariablePostprocessor.h:23

Referenced by MultiAppConservativeTransfer::postExecute().

◆ blockRestricted()

bool MultiAppUserObjectTransfer::blockRestricted ( ) const
protected
Returns
true if this transfer is restricted to a block, otherwise false

Definition at line 572 of file MultiAppUserObjectTransfer.C.

573{
574 return !_blk_ids.empty();
575}
MultiAppUserObjectTransfer::_blk_ids
std::set< SubdomainID > _blk_ids
Set of block ids this transfer is restricted to.
Definition MultiAppUserObjectTransfer.h:106

Referenced by execute().

◆ boundaryRestricted()

bool MultiAppUserObjectTransfer::boundaryRestricted ( ) const
protected
Returns
true if this transfer is restricted to a boundary, otherwise false

Definition at line 578 of file MultiAppUserObjectTransfer.C.

579{
580 return !_bnd_ids.empty();
581}
MultiAppUserObjectTransfer::_bnd_ids
std::set< BoundaryID > _bnd_ids
Set of the boundary ids.
Definition MultiAppUserObjectTransfer.h:109

Referenced by execute().

◆ callMooseError() [1/2]

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

External method for calling moose error with added object context.

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

Parameters
appThe app pointer (if available); adds multiapp context and clears the console
paramsThe parameters, needed to obtain object information
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix
show_traceWhether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

120{
121 if (!node)
122 node = MooseBase::getHitNode(params);
123
124 std::string multiapp_prefix = "";
125 if (app)
126 {
127 if (!app->isUltimateMaster())
128 multiapp_prefix = app->name();
129 app->getOutputWarehouse().mooseConsole();
130 }
131
132 if (with_prefix)
133 // False here because the hit context will get processed by the node
134 msg = messagePrefix(params, false) + msg;
135
136 moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
137}
MooseApp::getOutputWarehouse
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition MooseApp.C:2409
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition MooseApp.h:866
MooseBase::getHitNode
const hit::Node * getHitNode() const
Definition MooseBase.h:136
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition MooseBase.h:256
OutputWarehouse::mooseConsole
void mooseConsole()
Send current output buffer to Console output objects.
Definition OutputWarehouse.C:199
moose::internal::mooseErrorRaw
void mooseErrorRaw(std::string msg, const std::string &prefix="", const hit::Node *node=nullptr, const bool show_trace=true)
Main callback for emitting a moose error.
Definition MooseError.C:53

◆ callMooseError() [2/2]

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

External method for calling moose error with added object context.

Parameters
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix
show_traceWhether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

109{
110 callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
111}
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition MooseBase.h:375
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
External method for calling moose error with added object context.
Definition MooseBase.C:105
MooseBase::_pars
const InputParameters & _pars
The object's parameters.
Definition MooseBase.h:384

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

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

174{
175 if (_from_multi_app && !_to_multi_app)
176 if (getExecuteOnEnum() != _from_multi_app->getExecuteOnEnum())
177 mooseDoOnce(
178 mooseWarning("MultiAppTransfer execute_on flags do not match associated from_multi_app "
179 "execute_on flags"));
180
181 if (_to_multi_app && !_from_multi_app)
182 if (getExecuteOnEnum() != _to_multi_app->getExecuteOnEnum())
183 mooseDoOnce(
184 mooseWarning("MultiAppTransfer execute_on flags do not match associated to_multi_app "
185 "execute_on flags"));
186
187 // In the case of siblings transfer, the check will be looser
188 if (_from_multi_app && _to_multi_app)
189 if (getExecuteOnEnum() != _from_multi_app->getExecuteOnEnum() &&
190 getExecuteOnEnum() != _to_multi_app->getExecuteOnEnum())
191 mooseDoOnce(
192 mooseWarning("MultiAppTransfer execute_on flags do not match associated to_multi_app "
193 "and from_multi_app execute_on flags"));
194}
MultiAppTransfer::_from_multi_app
std::shared_ptr< MultiApp > _from_multi_app
The MultiApps this Transfer is transferring data to or from.
Definition MultiAppTransfer.h:320
MultiAppTransfer::_to_multi_app
std::shared_ptr< MultiApp > _to_multi_app
Definition MultiAppTransfer.h:321
SetupInterface::getExecuteOnEnum
const ExecFlagEnum & getExecuteOnEnum() const
Return the execute on MultiMooseEnum for this object.
Definition SetupInterface.C:73
SolutionInvalidInterface::mooseWarning
void mooseWarning(Args &&... args) const
Definition SolutionInvalidInterface.h:73

Referenced by MultiAppTransfer::MultiAppTransfer().

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

689{
690 // Source app is not the parent, most execution schedules are fine since the transfer occurs after
691 // the app has run NOTE: not true for siblings transfer
692 if (hasFromMultiApp())
693 return;
694 // Get user object from parent. We don't know the type
695 const auto & uo = _fe_problem.getUserObject<UserObject>(object_name);
696 // If we are executing on transfers, every additional schedule is not a problem
697 if (uo.getExecuteOnEnum().contains(EXEC_TRANSFER))
698 return;
699 // If we are transferring on the same schedule as we are executing, we are lagging. Is it on
700 // purpose? We don't know, so we will give a warning unless silenced.
701 // The derived-classes offer the parameter to silence this warning
702 // Note: UOs execute before transfers on INITIAL so it's not a problem at this time
703 if (uo.getExecuteOnEnum().contains(_fe_problem.getCurrentExecuteOnFlag()) &&
704 _fe_problem.getCurrentExecuteOnFlag() != EXEC_INITIAL)
705 if (!isParamValid("warn_source_object_execution_schedule") ||
706 getParam<bool>("warn_source_object_execution_schedule"))
707 uo.paramWarning("execute_on",
708 "This UserObject-derived class is being executed on '" +
709 Moose::stringify(_fe_problem.getCurrentExecuteOnFlag()) +
710 "' and also providing values for the '" + name() +
711 "' transfer, on that same execution schedule. Because user objects are "
712 "executed after transfers are, this means the values provided by this "
713 "user object are lagged. If you are ok with this, then set the "
714 "'warn_source_object_execution_schedule' parameter to false in this "
715 "Transfer. If not, then execute '" +
716 uo.name() +
717 "' on TRANSFER by adding it to the 'execute_on' vector parameter.");
718}
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL
Definition Moose.C:30
FEProblemBase::getUserObject
T & getUserObject(const std::string &name, unsigned int tid=0) const
Get the user object by its name.
Definition FEProblemBase.h:1399
FEProblemBase::getCurrentExecuteOnFlag
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
Definition FEProblemBase.C:5061
MultiAppTransfer::hasFromMultiApp
bool hasFromMultiApp() const
Whether the transfer owns a non-null from_multi_app.
Definition MultiAppTransfer.h:113
SolutionInvalidInterface::paramWarning
void paramWarning(const std::string &param, Args... args) const
Definition SolutionInvalidInterface.h:94
UserObject
Base class for user-specific data.
Definition UserObject.h:20
Moose::stringify
std::string stringify(const T &t)
conversion to string
Definition Conversion.h:64

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

◆ checkSiblingsTransferSupported()

virtual void MultiAppTransfer::checkSiblingsTransferSupported ( ) const
inlineprotectedvirtualinherited

Whether the transfer supports siblings transfer.

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

Definition at line 232 of file MultiAppTransfer.h.

233 {
234 mooseError("Siblings transfer not supported. You cannot transfer both from a multiapp to "
235 "another multiapp");
236 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition MooseBase.h:271

Referenced by MultiAppTransfer::initialSetup().

◆ 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_problemThe problem that should contain the variable
var_nameThe 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.

616{
617 if (!fe_problem.hasVariable(var_name))
618 {
619 if (param_name.empty())
620 mooseError("The variable '", var_name, "' does not exist.");
621 else
622 paramError(param_name, "The variable '", var_name, "' does not exist.");
623 }
624}
FEProblemBase::hasVariable
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
Definition FEProblemBase.C:6234

Referenced by MultiAppDofCopyTransfer::transfer().

◆ connectControllableParams()

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

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

Parameters
parameterName of the controllable parameter of this action
object_typeType of the object added by this action.
object_nameName of the object added by this action.
object_parameterName of the parameter of the object.

Definition at line 77 of file MooseBase.C.

81{
82 auto & factory = _app.getFactory();
83 auto & ip_warehouse = _app.getInputParameterWarehouse();
84
85 MooseObjectParameterName primary_name(uniqueName(), parameter);
86 const auto base_type = factory.getValidParams(object_type).getBase();
87 MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
88 ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
89
90 const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
91 for (const auto & tag : tags)
92 {
93 if (!tag.empty())
94 {
95 // Only adds the parameter with the different control tags if the derived class
96 // properly registers the parameter to its own syntax
97 MooseObjectParameterName tagged_name(tag, name(), parameter);
98 ip_warehouse.addControllableParameterConnection(
99 tagged_name, secondary_name, /*error_on_empty=*/false);
100 }
101 }
102}
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition InputParameters.h:2342
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition MooseApp.h:407
MooseApp::getInputParameterWarehouse
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition MooseApp.C:2867
MooseBase::uniqueName
MooseObjectName uniqueName() const
Definition MooseBase.C:69
MooseObjectParameterName
A class for storing an input parameter name.
Definition MooseObjectParameterName.h:27

◆ currentDirection()

MooseEnum Transfer::currentDirection ( )
inlineinherited

Definition at line 85 of file Transfer.h.

85{ 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 69 of file SetupInterface.h.

69{}

◆ 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 283 of file Restartable.h.

286{
287 auto & data_ptr =
288 declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
289 return Restartable::ManagedValue<T>(data_ptr);
290}
Restartable::ManagedValue
Wrapper class for restartable data that is "managed.
Definition Restartable.h:43

◆ 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_nameThe name of the data (usually just use the same name as the member variable)
argsArguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

359{
360 const auto full_name = restartableName(data_name);
361
362 registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
363
364 return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
365}
Restartable::restartableName
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 nam...
Definition Restartable.C:78
Restartable::registerRestartableNameWithFilterOnApp
void registerRestartableNameWithFilterOnApp(const std::string &name, Moose::RESTARTABLE_FILTER filter)
Helper function for actually registering the restartable data.
Definition Restartable.C:71

◆ 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_nameThe name of the data (usually just use the same name as the member variable)
argsArguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

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

◆ declareRestartableDataHelper()

template<typename T , typename... Args>
RestartableData< T > & Restartable::declareRestartableDataHelper ( const std::string &  data_name,
void *  context,
Args &&...  args 
) const
privateinherited

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
contextContext pointer that will be passed to the load and store functions
argsArguments to forward to the constructor of the data

Definition at line 310 of file Restartable.h.

313{
314 const auto full_name = restartableName(data_name);
315
316 // Here we will create the RestartableData even though we may not use this instance.
317 // If it's already in use, the App will return a reference to the existing instance and we'll
318 // return that one instead. We might refactor this to have the app create the RestartableData
319 // at a later date.
320 auto data_ptr =
321 std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
322 auto & restartable_data_ref = static_cast<RestartableData<T> &>(
323 registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
324
325 return restartable_data_ref;
326}
RestartableData
Concrete definition of a parameter value for a specified type.
Definition RestartableData.h:216
Restartable::_restartable_tid
const THREAD_ID _restartable_tid
The thread ID for this object.
Definition Restartable.h:240
Restartable::registerRestartableDataOnApp
RestartableDataValue & registerRestartableDataOnApp(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
Helper function for actually registering the restartable data.
Definition Restartable.C:63

◆ 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_nameThe name of the data (usually just use the same name as the member variable)
contextContext pointer that will be passed to the load and store functions
argsArguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

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

◆ 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_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.
argsArguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

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

◆ 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_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.
contextContext pointer that will be passed to the load and store functions
argsArguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

344{
345 std::string old_name = _restartable_name;
346
347 _restartable_name = object_name;
348
349 T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
350
351 _restartable_name = old_name;
352
353 return value;
354}
Restartable::_restartable_name
std::string _restartable_name
The name of the object.
Definition Restartable.h:250
libMesh::JacobiPolynomials::value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

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

84{ return _direction; }
Transfer::_direction
MooseEnum _direction
Definition Transfer.h:105

Referenced by Transfer::setCurrentDirection().

◆ directions()

const MultiMooseEnum & Transfer::directions ( )
inlineinherited

The directions this Transfer should be executed on.

Definition at line 79 of file Transfer.h.

79{ return _directions; }
Transfer::_directions
MultiMooseEnum _directions
The directions this Transfer is to be executed on.
Definition Transfer.h:110

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }
MooseObject::_enabled
const bool & _enabled
Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.
Definition MooseObject.h:71

Referenced by EigenKernel::enabled(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and NodeFaceConstraint::validParams().

◆ 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 \emph desired to use EXEC_TRANSFER for a MooseObject that provides the values to transfer.

Parameters
object_namename of the object to check the execute_on flags for

Definition at line 721 of file MultiAppTransfer.C.

722{
723 // parent app is the source app, EXEC_TRANSFER is fine
724 if (!hasFromMultiApp())
725 return;
726 // Get the app and problem
727 const auto & app = getFromMultiApp();
728 if (!app->hasApp())
729 return;
730 const auto & problem = app->appProblemBase(app->firstLocalApp());
731 // Use the warehouse to find the object
732 std::vector<SetupInterface *> objects_with_exec_on;
733 problem.theWarehouse()
734 .query()
735 .template condition<AttribName>(object_name)
736 .template condition<AttribExecOns>(EXEC_TRANSFER)
737 .queryInto(objects_with_exec_on);
738 if (objects_with_exec_on.size())
739 mooseError("Object '" + object_name +
740 "' should not be executed on EXEC_TRANSFER, because this transfer has "
741 "indicated it does not support it.\nExecuting this object on TIMESTEP_END should be "
742 "sufficient to get updated values.");
743}

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

◆ errorPrefix()

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

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

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ execute()

void MultiAppUserObjectTransfer::execute ( )
overridevirtual

Execute the transfer.

Implements Transfer.

Definition at line 116 of file MultiAppUserObjectTransfer.C.

117{
118 TIME_SECTION(
119 "MultiAppUserObjectTransfer::execute()", 5, "Performing transfer with a user object");
120
121 getAppInfo();
122
123 // Execute the user object if it was specified to execute on TRANSFER
124 switch (_current_direction)
125 {
126 case TO_MULTIAPP:
127 {
128 checkParentAppUserObjectExecuteOn(_user_object_name);
129 _fe_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::PRE_AUX, _user_object_name);
130 _fe_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, _user_object_name);
131 break;
132 }
133 case FROM_MULTIAPP:
134 errorIfObjectExecutesOnTransferInSourceApp(_user_object_name);
135 }
136
137 switch (_current_direction)
138 {
139 case TO_MULTIAPP:
140 {
141 for (unsigned int i = 0; i < getToMultiApp()->numGlobalApps(); i++)
142 {
143 if (getToMultiApp()->hasLocalApp(i))
144 {
145 Moose::ScopedCommSwapper swapper(getToMultiApp()->comm());
146
147 // Loop over the parent app nodes and set the value of the variable
148 System * to_sys = find_sys(getToMultiApp()->appProblemBase(i).es(), _to_var_name);
149
150 unsigned int sys_num = to_sys->number();
151 unsigned int var_num = to_sys->variable_number(_to_var_name);
152
153 NumericVector<Real> & solution = getToMultiApp()->appTransferVector(i, _to_var_name);
154
155 MooseMesh * mesh = NULL;
156
157 if (_displaced_target_mesh && getToMultiApp()->appProblemBase(i).getDisplacedProblem())
158 mesh = &getToMultiApp()->appProblemBase(i).getDisplacedProblem()->mesh();
159 else
160 mesh = &getToMultiApp()->appProblemBase(i).mesh();
161
162 _blk_ids.clear();
163 _bnd_ids.clear();
164 if (isParamValid("block"))
165 {
166 const std::vector<SubdomainName> & blocks =
167 getParam<std::vector<SubdomainName>>("block");
168 for (const auto & b : blocks)
169 if (!MooseMeshUtils::hasSubdomainName(*mesh, b))
170 paramError("block", "The block '", b, "' was not found in the mesh");
171
172 std::vector<SubdomainID> ids = mesh->getSubdomainIDs(blocks);
173 _blk_ids.insert(ids.begin(), ids.end());
174 }
175 else if (isParamValid("boundary"))
176 {
177 const std::vector<BoundaryName> & boundary_names =
178 getParam<std::vector<BoundaryName>>("boundary");
179 for (const auto & b : boundary_names)
180 if (!MooseMeshUtils::hasBoundaryNameOrID(*mesh, b))
181 paramError("boundary", "The boundary '", b, "' was not found in the mesh");
182
183 std::vector<BoundaryID> ids = mesh->getBoundaryIDs(boundary_names, true);
184 _bnd_ids.insert(ids.begin(), ids.end());
185 }
186
187 auto & fe_type = to_sys->variable_type(var_num);
188 bool is_constant = fe_type.order == CONSTANT;
189 bool is_nodal = fe_type.family == LAGRANGE;
190
191 if (fe_type.order > FIRST && !is_nodal)
192 mooseError("We don't currently support second order or higher elemental variable ");
193
194 const UserObject & user_object =
195 getToMultiApp()->problemBase().getUserObjectBase(_user_object_name);
196 mooseAssert(_from_transforms.size() == 1, "This should have size 1");
197 const auto & from_transform = *_from_transforms[0];
198 const auto & to_transform = *_to_transforms[i];
199
200 if (is_nodal)
201 {
202 for (auto & node : mesh->getMesh().local_node_ptr_range())
203 {
204 if (blockRestricted() && !hasBlocks(mesh, node))
205 continue;
206
207 if (boundaryRestricted() && !isBoundaryNode(mesh, node))
208 continue;
209
210 if (node->n_dofs(sys_num, var_num) > 0) // If this variable has dofs at this node
211 {
212 // The zero only works for LAGRANGE!
213 dof_id_type dof = node->dof_number(sys_num, var_num, 0);
214
215 swapper.forceSwap();
216 Real from_value =
217 user_object.spatialValue(from_transform.mapBack(to_transform(*node)));
218 swapper.forceSwap();
219
220 solution.set(dof, from_value);
221 }
222 }
223 }
224 else // Elemental
225 {
226 std::vector<Point> points;
227 for (auto & elem : as_range(mesh->getMesh().local_elements_begin(),
228 mesh->getMesh().local_elements_end()))
229 {
230 if (blockRestricted() && !hasBlocks(elem))
231 continue;
232
233 if (boundaryRestricted() && !isBoundaryElem(mesh, elem))
234 continue;
235
236 // Skip this element if the variable has no dofs at it.
237 if (elem->n_dofs(sys_num, var_num) < 1)
238 continue;
239
240 points.clear();
241 // grap sample points
242 // for constant shape function, we take the element centroid
243 if (is_constant)
244 points.push_back(elem->vertex_average());
245 // for higher order method, we take all nodes of element
246 // this works for the first order L2 Lagrange.
247 else
248 for (auto & node : elem->node_ref_range())
249 points.push_back(node);
250
251 auto n_points = points.size();
252 unsigned int n_comp = elem->n_comp(sys_num, var_num);
253 // We assume each point corresponds to one component of elemental variable
254 if (n_points != n_comp)
255 mooseError(" Number of points ",
256 n_points,
257 " does not equal to number of variable components ",
258 n_comp);
259
260 unsigned int offset = 0;
261 for (auto & point : points) // If this variable has dofs at this elem
262 {
263 dof_id_type dof = elem->dof_number(sys_num, var_num, offset++);
264
265 swapper.forceSwap();
266 Real from_value =
267 user_object.spatialValue(from_transform.mapBack(to_transform(point)));
268 swapper.forceSwap();
269
270 solution.set(dof, from_value);
271 }
272 }
273 }
274
275 solution.close();
276 to_sys->update();
277 }
278 }
279
280 break;
281 }
282 case FROM_MULTIAPP:
283 {
284 FEProblemBase & to_problem = getFromMultiApp()->problemBase();
285 mooseAssert(_to_transforms.size() == 1, "This should only be size one");
286 const auto & to_transform = *_to_transforms[0];
287 MooseVariableFEBase & to_var = to_problem.getVariable(
288 0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
289 SystemBase & to_system_base = to_var.sys();
290
291 System & to_sys = to_system_base.system();
292
293 unsigned int to_sys_num = to_sys.number();
294
295 // Only works with a serialized mesh to transfer to!
296 mooseAssert(to_sys.get_mesh().is_serial(),
297 "MultiAppUserObjectTransfer only works with ReplicatedMesh!");
298
299 unsigned int to_var_num = to_sys.variable_number(to_var.name());
300
301 // EquationSystems & to_es = to_sys.get_equation_systems();
302
303 // Create a serialized version of the solution vector
304 NumericVector<Number> * to_solution = to_sys.solution.get();
305
306 MooseMesh * to_mesh = NULL;
307
308 if (_displaced_target_mesh && to_problem.getDisplacedProblem())
309 to_mesh = &to_problem.getDisplacedProblem()->mesh();
310 else
311 to_mesh = &to_problem.mesh();
312
313 _blk_ids.clear();
314 _bnd_ids.clear();
315 if (isParamValid("block"))
316 {
317 const std::vector<SubdomainName> & blocks = getParam<std::vector<SubdomainName>>("block");
318 for (const auto & b : blocks)
319 if (!MooseMeshUtils::hasSubdomainName(*to_mesh, b))
320 paramError("block", "The block '", b, "' was not found in the mesh");
321
322 std::vector<SubdomainID> ids = to_mesh->getSubdomainIDs(blocks);
323 _blk_ids.insert(ids.begin(), ids.end());
324 }
325 else if (isParamValid("boundary"))
326 {
327 const std::vector<BoundaryName> & boundary_names =
328 getParam<std::vector<BoundaryName>>("boundary");
329 for (const auto & b : boundary_names)
330 if (!MooseMeshUtils::hasBoundaryNameOrID(*to_mesh, b))
331 paramError("boundary", "The boundary '", b, "' was not found in the mesh");
332
333 std::vector<BoundaryID> ids = to_mesh->getBoundaryIDs(boundary_names, true);
334 _bnd_ids.insert(ids.begin(), ids.end());
335 }
336
337 auto & fe_type = to_sys.variable_type(to_var_num);
338 bool is_constant = fe_type.order == CONSTANT;
339 bool is_nodal = fe_type.family == LAGRANGE;
340
341 if (fe_type.order > FIRST && !is_nodal)
342 mooseError("We don't currently support second order or higher elemental variable ");
343
344 if (_all_parent_nodes_contained_in_sub_app)
345 {
346 // check to see if parent app nodes or elements lies within any of the sub application
347 // bounding boxes
348 if (is_nodal)
349 {
350 for (auto & node : to_mesh->getMesh().node_ptr_range())
351 {
352 if (blockRestricted() && !hasBlocks(to_mesh, node))
353 continue;
354
355 if (boundaryRestricted() && !isBoundaryNode(to_mesh, node))
356 continue;
357
358 if (node->n_dofs(to_sys_num, to_var_num) > 0)
359 {
360 const auto transformed_node = to_transform(*node);
361
362 unsigned int node_found_in_sub_app = 0;
363 for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
364 {
365 if (!getFromMultiApp()->hasLocalApp(i))
366 continue;
367
368 BoundingBox app_box = getFromMultiApp()->getBoundingBox(
369 i, _displaced_source_mesh, _from_transforms[i].get());
370
371 if (app_box.contains_point(transformed_node))
372 ++node_found_in_sub_app;
373 }
374
375 if (node_found_in_sub_app == 0)
376 mooseError("MultiAppUserObjectTransfer: Parent app node ",
377 transformed_node,
378 " not found within the bounding box of any of the sub applications.");
379 else if (node_found_in_sub_app > 1)
380 mooseError("MultiAppUserObjectTransfer: Parent app node ",
381 transformed_node,
382 " found within the bounding box of two or more sub applications.");
383 }
384 }
385 }
386 else // elemental
387 {
388 std::vector<Point> points;
389 for (auto & elem :
390 as_range(to_mesh->getMesh().elements_begin(), to_mesh->getMesh().elements_end()))
391 {
392 if (blockRestricted() && !hasBlocks(elem))
393 continue;
394
395 if (boundaryRestricted() && !isBoundaryElem(to_mesh, elem))
396 continue;
397
398 // Skip this element if the variable has no dofs at it.
399 if (elem->n_dofs(to_sys_num, to_var_num) < 1)
400 continue;
401
402 points.clear();
403 // grap sample points
404 // for constant shape function, we take the element centroid
405 if (is_constant)
406 points.push_back(to_transform(elem->vertex_average()));
407 // for higher order method, we take all nodes of element
408 // this works for the first order L2 Lagrange.
409 else
410 for (auto & node : elem->node_ref_range())
411 points.push_back(to_transform(node));
412
413 auto n_points = points.size();
414 unsigned int n_comp = elem->n_comp(to_sys_num, to_var_num);
415 // We assume each point corresponds to one component of elemental variable
416 if (n_points != n_comp)
417 mooseError(" Number of points ",
418 n_points,
419 " does not equal to number of variable components ",
420 n_comp);
421
422 for (auto & point : points)
423 {
424 unsigned int elem_found_in_sub_app = 0;
425
426 for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
427 {
428 if (!getFromMultiApp()->hasLocalApp(i))
429 continue;
430
431 BoundingBox app_box = getFromMultiApp()->getBoundingBox(
432 i, _displaced_source_mesh, _from_transforms[i].get());
433
434 if (app_box.contains_point(point))
435 ++elem_found_in_sub_app;
436 }
437
438 if (elem_found_in_sub_app == 0)
439 mooseError("MultiAppUserObjectTransfer: Parent app element with ",
440 n_points > 1 ? "node" : "centroid",
441 " at ",
442 point,
443 " not found within the bounding box of any of the sub applications.");
444
445 else if (elem_found_in_sub_app > 1)
446 mooseError("MultiAppUserObjectTransfer: Parent app element with ",
447 n_points > 1 ? "node" : "centroid",
448 " at ",
449 point,
450 " found within the bounding box of two or more sub applications.");
451 }
452 }
453 }
454 }
455
456 if (is_nodal)
457 {
458 for (auto & node : to_mesh->getMesh().node_ptr_range())
459 {
460 if (blockRestricted() && !hasBlocks(to_mesh, node))
461 continue;
462
463 if (boundaryRestricted() && !isBoundaryNode(to_mesh, node))
464 continue;
465
466 if (node->n_dofs(to_sys_num, to_var_num) > 0) // If this variable has dofs at this node
467 {
468 const auto transformed_node = to_transform(*node);
469 const auto sub_app = findSubAppToTransferFrom(transformed_node);
470
471 // Check to see if a sub-app was found
472 if (sub_app == static_cast<unsigned int>(-1))
473 continue;
474
475 const auto & from_transform = *_from_transforms[sub_app];
476 const auto & user_object = _multi_app->appUserObjectBase(sub_app, _user_object_name);
477
478 dof_id_type dof = node->dof_number(to_sys_num, to_var_num, 0);
479
480 Real from_value = 0;
481 {
482 Moose::ScopedCommSwapper swapper(getFromMultiApp()->comm());
483 from_value = user_object.spatialValue(from_transform.mapBack(transformed_node));
484 }
485
486 if (from_value == std::numeric_limits<Real>::infinity())
487 mooseError("MultiAppUserObjectTransfer: Point corresponding to parent app node at (",
488 transformed_node,
489 ") not found in the sub application.");
490 to_solution->set(dof, from_value);
491 }
492 }
493 }
494 else // Elemental
495 {
496 std::vector<Point> points;
497 for (auto & elem :
498 as_range(to_mesh->getMesh().elements_begin(), to_mesh->getMesh().elements_end()))
499 {
500 if (blockRestricted() && !hasBlocks(elem))
501 continue;
502
503 if (boundaryRestricted() && !isBoundaryElem(to_mesh, elem))
504 continue;
505
506 // Skip this element if the variable has no dofs at it.
507 if (elem->n_dofs(to_sys_num, to_var_num) < 1)
508 continue;
509
510 points.clear();
511 // grap sample points
512 // for constant shape function, we take the element centroid
513 if (is_constant)
514 points.push_back(to_transform(elem->vertex_average()));
515 // for higher order method, we take all nodes of element
516 // this works for the first order L2 Lagrange.
517 else
518 for (auto & node : elem->node_ref_range())
519 points.push_back(to_transform(node));
520
521 auto n_points = points.size();
522 unsigned int n_comp = elem->n_comp(to_sys_num, to_var_num);
523 // We assume each point corresponds to one component of elemental variable
524 if (n_points != n_comp)
525 mooseError(" Number of points ",
526 n_points,
527 " does not equal to number of variable components ",
528 n_comp);
529
530 unsigned int offset = 0;
531 for (auto & point : points) // If this variable has dofs at this elem
532 {
533 const auto sub_app = findSubAppToTransferFrom(point);
534
535 // Check to see if a sub-app was found
536 if (sub_app == static_cast<unsigned int>(-1))
537 continue;
538
539 const auto & from_transform = *_from_transforms[sub_app];
540 const auto & user_object =
541 getFromMultiApp()->appUserObjectBase(sub_app, _user_object_name);
542
543 dof_id_type dof = elem->dof_number(to_sys_num, to_var_num, offset++);
544
545 Real from_value = 0;
546 {
547 Moose::ScopedCommSwapper swapper(getFromMultiApp()->comm());
548 from_value = user_object.spatialValue(from_transform.mapBack(point));
549 }
550
551 if (from_value == std::numeric_limits<Real>::infinity())
552 mooseError("MultiAppUserObjectTransfer: Point corresponding to element's centroid (",
553 point,
554 ") not found in sub application.");
555
556 to_solution->set(dof, from_value);
557 }
558 }
559 }
560
561 to_solution->close();
562 to_sys.update();
563
564 break;
565 }
566 }
567
568 postExecute();
569}
if
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
blocks
char ** blocks
Definition PetscDMMoose.C:1733
FEProblemBase
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition FEProblemBase.h:158
FEProblemBase::getDisplacedProblem
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
Definition FEProblemBase.h:1989
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition MooseMesh.h:95
MooseMesh::getSubdomainIDs
std::vector< SubdomainID > getSubdomainIDs(const std::vector< SubdomainName > &subdomain_names) const
Get the associated subdomainIDs for the subdomain names that are passed in.
Definition MooseMesh.C:1726
MooseMesh::getBoundaryIDs
std::vector< BoundaryID > getBoundaryIDs(const Elem *const elem, const unsigned short int side) const
Returns a vector of boundary IDs for the requested element on the requested side.
Definition MooseMesh.C:3027
MooseVariableFieldBase
This class provides an interface for common operations on field variables of both FE and FV types wit...
Definition MooseVariableFieldBase.h:30
MultiAppConservativeTransfer::postExecute
virtual void postExecute()
Add some extra work if necessary after execute().
Definition MultiAppConservativeTransfer.C:215
MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp
void errorIfObjectExecutesOnTransferInSourceApp(const std::string &object_name) const
Error if executing this MooseObject on EXEC_TRANSFER in a source multiapp (from_multiapp,...
Definition MultiAppTransfer.C:721
MultiAppTransfer::_displaced_source_mesh
bool _displaced_source_mesh
True if displaced mesh is used for the source mesh, otherwise false.
Definition MultiAppTransfer.h:169
MultiAppTransfer::getAppInfo
virtual void getAppInfo()
This method will fill information into the convenience member variables (_to_problems,...
Definition MultiAppTransfer.C:243
MultiAppTransfer::_from_transforms
std::vector< std::unique_ptr< MultiAppCoordTransform > > _from_transforms
Definition MultiAppTransfer.h:162
MultiAppTransfer::_displaced_target_mesh
bool _displaced_target_mesh
True if displaced mesh is used for the target mesh, otherwise false.
Definition MultiAppTransfer.h:171
MultiAppTransfer::checkParentAppUserObjectExecuteOn
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 al...
Definition MultiAppTransfer.C:688
MultiAppTransfer::_to_transforms
std::vector< std::unique_ptr< MultiAppCoordTransform > > _to_transforms
Definition MultiAppTransfer.h:161
MultiAppTransfer::_multi_app
std::shared_ptr< MultiApp > _multi_app
Deprecated class attribute for compatibility with the apps.
Definition MultiAppTransfer.h:151
MultiAppUserObjectTransfer::isBoundaryElem
bool isBoundaryElem(const MooseMesh *mesh, const Elem *elem) const
Check that the element belongs to boundary this transfer is restricted to.
Definition MultiAppUserObjectTransfer.C:612
MultiAppUserObjectTransfer::hasBlocks
bool hasBlocks(const Elem *elem) const
Check that element 'elem' is part of the domain this transfer is restricted to.
Definition MultiAppUserObjectTransfer.C:584
MultiAppUserObjectTransfer::findSubAppToTransferFrom
unsigned int findSubAppToTransferFrom(const Point &p)
Gets the UserObject to transfer from when transferring from_multiapp.
Definition MultiAppUserObjectTransfer.C:621
MultiAppUserObjectTransfer::isBoundaryNode
bool isBoundaryNode(const MooseMesh *mesh, const Node *node) const
Check that the node belongs to boundary this transfer is restricted to.
Definition MultiAppUserObjectTransfer.C:603
SystemBase
Base class for a system (of equations)
Definition SystemBase.h:87
Transfer::find_sys
static libMesh::System * find_sys(libMesh::EquationSystems &es, const std::string &var_name)
Small helper function for finding the system containing the variable.
Definition Transfer.C:91
UserObjectInterface::getUserObjectBase
const UserObjectBase & getUserObjectBase(const std::string &param_name, bool is_dependency=true) const
Get an user object with a given parameter param_name.
Definition UserObjectInterface.C:115
UserObject::spatialValue
virtual Real spatialValue(const Point &) const
Optional interface function for "evaluating" a UserObject at a spatial position.
Definition UserObject.h:36
libMesh::System::number
unsigned int number() const
mesh
MeshBase & mesh
MooseMeshUtils::hasSubdomainName
bool hasSubdomainName(const MeshBase &input_mesh, const SubdomainName &name)
Whether a particular subdomain name exists in the mesh.
MooseMeshUtils::hasBoundaryNameOrID
bool hasBoundaryNameOrID(const MeshBase &mesh, const BoundaryName &name_or_id)
Whether a particular boundary name or ID exists in the mesh.
Moose::PRE_AUX
@ PRE_AUX
Definition MooseTypes.h:760
libMesh::ReferenceElem::get
const Elem & get(const ElemType type_in)

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

467{
468 const auto extension_factor = factor - 1;
469
470 // Extend (or contract if the extension factor is negative) bounding boxes along all the
471 // directions by the same length. Greater than zero values of this member may be necessary because
472 // the nearest bounding box does not necessarily give you the closest node/element. It will depend
473 // on the partition and geometry. A node/element will more likely find its nearest source
474 // element/node by extending bounding boxes. If each of the bounding boxes covers the entire
475 // domain, a node/element will be able to find its nearest source element/node for sure, but at
476 // the same time, more communication will be involved and can be expensive.
477 for (auto & box : bboxes)
478 {
479 // libmesh set an invalid bounding box using this code
480 // for (unsigned int i=0; i<LIBMESH_DIM; i++)
481 // {
482 // this->first(i) = std::numeric_limits<Real>::max();
483 // this->second(i) = -std::numeric_limits<Real>::max();
484 // }
485 // If it is an invalid box, we should skip it
486 if (box.first(0) == std::numeric_limits<Real>::max())
487 continue;
488
489 auto width = box.second - box.first;
490 box.second += width * extension_factor;
491 box.first -= width * extension_factor;
492 }
493}

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

◆ 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
esThe EquationSystems object to be searched.
var_nameThe 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.

92{
93 // Find the system this variable is from
94 for (unsigned int i = 0; i < es.n_systems(); i++)
95 if (es.get_system(i).has_variable(var_name))
96 return &es.get_system(i);
97
98 ::mooseError("Unable to find variable " + var_name + " in any system.");
99
100 // Unreachable
101 return &es.get_system(0);
102}
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const

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

◆ findSubAppToTransferFrom()

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

Gets the UserObject to transfer from when transferring from_multiapp.

Parameters
pThe point in the parent app that is being transferred to
Returns
the subapp index, will return static_cast<unsigned int>(-1) if none is found

Definition at line 621 of file MultiAppUserObjectTransfer.C.

622{
623 // Just find the nearest app to this point
624 if (_nearest_sub_app)
625 {
626 unsigned int closest_app = 0;
627 Real closest_distance = std::numeric_limits<Real>::max();
628
629 mooseAssert(_multi_app->numGlobalApps() > 0, "No Multiapps To Transfer From");
630
631 for (unsigned int i = 0; i < _multi_app->numGlobalApps(); i++)
632 {
633 // Obtain the possibly transformed app position by querying the transform with the origin
634 const auto app_position = _multi_app->runningInPosition()
635 ? (*_from_transforms[i])(_multi_app->position(i))
636 : (*_from_transforms[i])(Point(0));
637
638 auto distance = (p - app_position).norm();
639
640 if (distance < closest_distance)
641 {
642 closest_app = i;
643 closest_distance = distance;
644 }
645 }
646
647 // We can only get the value if we have this app
648 // otherwise - another processor will set it
649 if (_multi_app->hasLocalApp(closest_app))
650 return closest_app;
651 else
652 return -1;
653 }
654
655 // Find the app that contains this point...
656
657 // This loop counts _down_ so that it can preserve legacy behavior of the
658 // last sub-app "winning" to be able to set the value at this point
659 for (int i = _multi_app->numGlobalApps() - 1; i >= 0; i--)
660 {
661 if (!_multi_app->hasLocalApp(i))
662 continue;
663
664 BoundingBox app_box =
665 _multi_app->getBoundingBox(i, _displaced_source_mesh, _from_transforms[i].get());
666
667 if (_skip_bbox_check || app_box.contains_point(p))
668 return static_cast<unsigned int>(i);
669 }
670
671 return -1;
672}
libMesh::TensorTools::norm
auto norm(const T &a)
distance
Real distance(const Point &p)

Referenced by execute().

◆ flagInvalidSolutionInternal()

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

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

43{
44 mooseAssert(
45 warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
46 "Inconsistent warning flag");
47 auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
48 if constexpr (!warning)
49 if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
50 solution_invalidity.printDebug(invalid_solution_id);
51 return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
52}
FEProblemBase::immediatelyPrintInvalidSolution
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
Definition FEProblemBase.h:2416
MooseApp::solutionInvalidity
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition MooseApp.h:185
MooseBase::getMooseApp
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition MooseBase.h:87
SolutionInvalidInterface::_si_problem
const FEProblemBase * _si_problem
A pointer to FEProblem base.
Definition SolutionInvalidInterface.h:114
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition SolutionInvalidInterface.h:111
SolutionInvalidity::printDebug
void printDebug(InvalidSolutionID _invalid_solution_id) const
Immediately print the section and message for debug purpose.
Definition SolutionInvalidity.C:208
moose::internal::getSolutionInvalidityRegistry
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.
Definition SolutionInvalidityRegistry.C:18

◆ getAppInfo()

void MultiAppTransfer::getAppInfo ( )
virtualinherited

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

Reimplemented in MultiAppGeneralFieldTransfer.

Definition at line 243 of file MultiAppTransfer.C.

244{
245 // I would like to do all of this in initialSetup, but it will fail with
246 // multiapps that reset. A reset deletes and rebuilds the FEProblems so all
247 // of the pointers will be broken.
248
249 // Clear the vectors since we've probably built them up from a previous call
250 _from_problems.clear();
251 _to_problems.clear();
252 _from_es.clear();
253 _to_es.clear();
254 _from_meshes.clear();
255 _to_meshes.clear();
256 _to_positions.clear();
257 _from_positions.clear();
258 _to_transforms.clear();
259 _from_transforms.clear();
260 // Clear this map since we build it from scratch every time we transfer
261 // Otherwise, this will cause two issues: 1) increasing memory usage
262 // for a simulation that requires many transfers, 2) producing wrong results
263 // when we do collective communication on this vector.
264 _to_local2global_map.clear();
265 _from_local2global_map.clear();
266
267 // Build the vectors for to problems, from problems, and subapps positions.
268 if (_current_direction == FROM_MULTIAPP)
269 {
270 _to_problems.push_back(&_from_multi_app->problemBase());
271 _to_positions.push_back(Point(0., 0., 0.));
272 getFromMultiAppInfo();
273 }
274 else if (_current_direction == TO_MULTIAPP)
275 {
276 _from_problems.push_back(&_to_multi_app->problemBase());
277 _from_positions.push_back(Point(0., 0., 0.));
278 getToMultiAppInfo();
279 }
280 else if (_current_direction == BETWEEN_MULTIAPP)
281 {
282 mooseAssert(&_from_multi_app->problemBase().coordTransform() ==
283 &_to_multi_app->problemBase().coordTransform(),
284 "I believe these should be the same. If not, then it will be difficult to define a "
285 "canonical reference frame.");
286 getToMultiAppInfo();
287 getFromMultiAppInfo();
288 }
289
290 // Build the from and to equation systems and mesh vectors.
291 for (unsigned int i = 0; i < _to_problems.size(); i++)
292 {
293 // TODO: Do I actually want es or displaced es?
294 _to_es.push_back(&_to_problems[i]->es());
295 if (_displaced_target_mesh && _to_problems[i]->getDisplacedProblem())
296 _to_meshes.push_back(&_to_problems[i]->getDisplacedProblem()->mesh());
297 else
298 _to_meshes.push_back(&_to_problems[i]->mesh());
299 }
300
301 for (unsigned int i = 0; i < _from_problems.size(); i++)
302 {
303 _from_es.push_back(&_from_problems[i]->es());
304 if (_displaced_source_mesh && _from_problems[i]->getDisplacedProblem())
305 _from_meshes.push_back(&_from_problems[i]->getDisplacedProblem()->mesh());
306 else
307 _from_meshes.push_back(&_from_problems[i]->mesh());
308 }
309
310 MooseAppCoordTransform::MinimalData from_app_transform_construction_data{};
311 if (_communicator.rank() == 0)
312 from_app_transform_construction_data =
313 _current_direction == TO_MULTIAPP
314 ? _to_multi_app->problemBase().coordTransform().minimalDataDescription()
315 : _from_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
316 _communicator.broadcast(from_app_transform_construction_data);
317 _from_moose_app_transform =
318 std::make_unique<MooseAppCoordTransform>(from_app_transform_construction_data);
319
320 MooseAppCoordTransform::MinimalData to_app_transform_construction_data{};
321 if (_communicator.rank() == 0)
322 to_app_transform_construction_data =
323 _current_direction == FROM_MULTIAPP
324 ? _from_multi_app->problemBase().coordTransform().minimalDataDescription()
325 : _to_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
326 _communicator.broadcast(to_app_transform_construction_data);
327 _to_moose_app_transform =
328 std::make_unique<MooseAppCoordTransform>(to_app_transform_construction_data);
329
330 /*
331 * skip_coordinate_collapsing: whether to set the transform to skip coordinate collapsing
332 * (from XYZ to RZ for example)
333 * transforms: vector of transforms to add the new transforms to
334 * moose_app_transform: base for the new transform
335 * is_parent_app_transform: whether working on the transform for the parent app (this app, the
336 * one creating the transfer) or for child apps
337 * multiapp: pointer to the multiapp to obtain the position of the child apps
338 */
339 auto create_multiapp_transforms = [this](auto & transforms,
340 const auto & moose_app_transform,
341 const bool is_parent_app_transform,
342 const MultiApp * const multiapp = nullptr)
343 {
344 mooseAssert(is_parent_app_transform || multiapp,
345 "Coordinate transform must be created either for child app or parent app");
346 if (is_parent_app_transform)
347 {
348 transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
349 transforms.back()->skipCoordinateCollapsing(_skip_coordinate_collapsing);
350 // zero translation
351 }
352 else
353 {
354 mooseAssert(transforms.size() == 0, "transforms should not be initialized at this point");
355 for (const auto i : make_range(multiapp->numGlobalApps()))
356 {
357 transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
358 auto & transform = transforms[i];
359 transform->skipCoordinateCollapsing(_skip_coordinate_collapsing);
360 if (multiapp->usingPositions())
361 transform->setTranslationVector(multiapp->position(i));
362 }
363 }
364 };
365
366 if (_current_direction == TO_MULTIAPP)
367 {
368 create_multiapp_transforms(
369 _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
370 create_multiapp_transforms(_from_transforms, *_from_moose_app_transform, true);
371 }
372 if (_current_direction == FROM_MULTIAPP)
373 {
374 create_multiapp_transforms(_to_transforms, *_to_moose_app_transform, true);
375 create_multiapp_transforms(
376 _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
377 }
378 if (_current_direction == BETWEEN_MULTIAPP)
379 {
380 create_multiapp_transforms(
381 _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
382 create_multiapp_transforms(
383 _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
384 }
385
386 auto check_transform_compatibility = [this](const MultiAppCoordTransform & transform)
387 {
388 if (transform.hasNonTranslationTransformation() && !usesMooseAppCoordTransform())
389 mooseWarning("Transfer '",
390 name(),
391 "' of type '",
392 type(),
393 "' has non-translation transformations but it does not implement coordinate "
394 "transformations using the 'MooseAppCoordTransform' class. Your data transfers "
395 "will not be performed in the expected transformed frame");
396 };
397
398 // set the destination coordinate systems for each transform for the purposes of determining
399 // coordinate collapsing. For example if TO is XYZ and FROM is RZ, then TO will have its XYZ
400 // coordinates collapsed into RZ and FROM will have a no-op for coordinate collapsing
401
402 for (const auto i : index_range(_from_transforms))
403 {
404 auto & from_transform = _from_transforms[i];
405 from_transform->setDestinationCoordTransform(*_to_moose_app_transform);
406 if (i == 0)
407 check_transform_compatibility(*from_transform);
408 }
409 for (const auto i : index_range(_to_transforms))
410 {
411 auto & to_transform = _to_transforms[i];
412 to_transform->setDestinationCoordTransform(*_from_moose_app_transform);
413 if (i == 0)
414 check_transform_compatibility(*to_transform);
415 }
416}
MooseAppCoordTransform::MinimalData
std::tuple< short int, Real, short int, std::array< Real, 3 >, int, unsigned int, unsigned int, short int, short int, short int > MinimalData
A typedef for conveniency that describes the minimal data necessary to broadcast and build a MooseApp...
Definition MooseAppCoordTransform.h:62
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition MooseBase.h:93
MultiAppCoordTransform
This class contains transformation information that only exists in a context in which there are multi...
Definition MooseAppCoordTransform.h:246
MultiAppTransfer::_to_moose_app_transform
std::unique_ptr< MooseAppCoordTransform > _to_moose_app_transform
The moose coordinate transformation object describing rotations, scaling, and coordinate system of th...
Definition MultiAppTransfer.h:332
MultiAppTransfer::_to_local2global_map
std::vector< unsigned int > _to_local2global_map
Given local app index, returns global app index.
Definition MultiAppTransfer.h:211
MultiAppTransfer::_from_positions
std::vector< Point > _from_positions
Definition MultiAppTransfer.h:160
MultiAppTransfer::usesMooseAppCoordTransform
virtual bool usesMooseAppCoordTransform() const
Whether this transfer handles non-translation-based transformations, e.g.
Definition MultiAppTransfer.h:308
MultiAppTransfer::_from_es
std::vector< libMesh::EquationSystems * > _from_es
Definition MultiAppTransfer.h:156
MultiAppTransfer::_from_local2global_map
std::vector< unsigned int > _from_local2global_map
Given local app index, returns global app index.
Definition MultiAppTransfer.h:213
MultiAppTransfer::_to_positions
std::vector< Point > _to_positions
Definition MultiAppTransfer.h:159
MultiAppTransfer::_from_meshes
std::vector< MooseMesh * > _from_meshes
Definition MultiAppTransfer.h:158
MultiAppTransfer::_from_problems
std::vector< FEProblemBase * > _from_problems
Definition MultiAppTransfer.h:154
MultiAppTransfer::_from_moose_app_transform
std::unique_ptr< MooseAppCoordTransform > _from_moose_app_transform
The moose coordinate transformation object describing rotations, scaling, and coordinate system of th...
Definition MultiAppTransfer.h:328
MultiAppTransfer::_to_problems
std::vector< FEProblemBase * > _to_problems
Definition MultiAppTransfer.h:153
MultiAppTransfer::_to_meshes
std::vector< MooseMesh * > _to_meshes
Definition MultiAppTransfer.h:157
MultiAppTransfer::_to_es
std::vector< libMesh::EquationSystems * > _to_es
Definition MultiAppTransfer.h:155
MultiAppTransfer::_skip_coordinate_collapsing
const bool _skip_coordinate_collapsing
Whether to skip coordinate collapsing (transformations of coordinates between applications using diff...
Definition MultiAppTransfer.h:166
MultiApp
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition MultiApp.h:116
libMesh::Parallel::Communicator::rank
processor_id_type rank() const
libMesh::Parallel::Communicator::broadcast
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
libMesh::index_range
auto index_range(const T &sizable)
libMesh::make_range
IntRange< T > make_range(T beg, T end)

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

◆ getBase()

const std::string & MooseBase::getBase ( ) const
inlineinherited
Returns
The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }
InputParameters::getBase
const std::string & getBase() const
Definition InputParameters.C:505

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

◆ getCheckedPointerParam()

template<typename T >
T MooseBase::getCheckedPointerParam ( const std::string &  name,
const std::string &  error_string = "" 
) const
inherited

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

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

Definition at line 450 of file MooseBase.h.

451{
452 return _pars.getCheckedPointerParam<T>(name, error_string);
453}
InputParameters::getCheckedPointerParam
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.
Definition InputParameters.h:1790

◆ getDataFileName()

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

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

22{
23 _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
24 "within the InputParameters.\nUse getParam<DataFileName>(\"",
25 param,
26 "\") instead.");
27 return _parent.getParam<DataFileName>(param);
28}
DataFileInterface::_parent
const ParallelParamObject & _parent
Definition DataFileInterface.h:58
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Emits a deprecation warning prefixed with the object name and type, and a stack trace.
Definition MooseBase.h:317

◆ getDataFileNameByName()

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

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

32{
33 _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
34 relative_path,
35 "\") instead.");
36 return getDataFilePath(relative_path);
37}
DataFileInterface::getDataFilePath
std::string getDataFilePath(const std::string &relative_path) const
Returns the path of a data file for a given relative file path.
Definition DataFileInterface.C:40

◆ getDataFilePath()

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

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

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

Definition at line 40 of file DataFileInterface.C.

41{
42 // This should only ever be used with relative paths. There is no point to
43 // use this search path with an absolute path.
44 if (std::filesystem::path(relative_path).is_absolute())
45 _parent.mooseWarning("While using getDataFilePath(\"",
46 relative_path,
47 "\"): This API should not be used for absolute paths.");
48
49 // This will search the data paths for this relative path
50 std::optional<std::string> error;
51 Moose::DataFileUtils::Path found_path;
52 {
53 // Throw on error so that if getPath() fails, we can throw an error
54 // with the context of _parent.mooseError()
55 Moose::ScopedThrowOnError scoped_throw_on_error;
56
57 try
58 {
59 found_path = Moose::DataFileUtils::getPath(relative_path);
60 }
61 catch (std::exception & e)
62 {
63 error = e.what();
64 }
65 }
66
67 if (error)
68 _parent.mooseError(*error);
69
70 mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
71 "Should only ever obtain data");
72 mooseAssert(found_path.data_name, "Should be set");
73
74 const std::string msg =
75 "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
76 _parent.mooseInfo(msg);
77
78 return found_path.path;
79}
MooseBase::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition MooseBase.h:299
MooseBase::mooseInfo
void mooseInfo(Args &&... args) const
Definition MooseBase.h:334
Moose::ScopedThrowOnError
Scoped helper for setting Moose::_throw_on_error during this scope.
Definition Moose.h:298
Moose::DataFileUtils::Context::DATA
@ DATA
From installed/in-tree data.
Moose::DataFileUtils::getPath
Path getPath(std::string path, const GetPathOptions &options={})
Get the data path for a given path, searching the registered data.
Definition DataFileUtils.C:22
Moose::DataFileUtils::Path
Representation of a data file path.
Definition DataFileUtils.h:41
Moose::DataFileUtils::Path::data_name
std::optional< std::string > data_name
The name of the data registry the file came from (with context == DATA)
Definition DataFileUtils.h:54
Moose::DataFileUtils::Path::context
Context context
Context for the file (where it came from)
Definition DataFileUtils.h:52

Referenced by DataFileInterface::getDataFileNameByName().

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

56{
57 if (use_displaced)
58 {
59 if (!problem.getDisplacedProblem())
60 mooseError("No displaced problem to provide a displaced equation system");
61 return problem.getDisplacedProblem()->es();
62 }
63 else
64 return problem.es();
65}
FEProblemBase::es
virtual libMesh::EquationSystems & es() override
Definition FEProblemBase.h:180

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

◆ getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const
inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 73 of file SetupInterface.C.

74{
75 return _execute_enum;
76}
SetupInterface::_execute_enum
const ExecFlagEnum & _execute_enum
Execute settings for this object.
Definition SetupInterface.h:83

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), MultiAppTransfer::checkMultiAppExecuteOn(), Control::Control(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), Exodus::outputSetup(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), NodalReporter::shouldStore(), and PIDTransientControl::timestepSetup().

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

497{
498 std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
499 for (unsigned int i = 0; i < _from_meshes.size(); i++)
500 {
501 // Get a bounding box around the mesh elements that are local to the current
502 // processor.
503 BoundingBox bbox = MeshTools::create_local_bounding_box(*_from_meshes[i]);
504
505 // Translate the bounding box to the from domain's position. We may have rotations so we must
506 // be careful in constructing the new min and max (first and second)
507 const auto from_global_num = getGlobalSourceAppIndex(i);
508 transformBoundingBox(bbox, *_from_transforms[from_global_num]);
509
510 // Cast the bounding box into a pair of points (so it can be put through
511 // MPI communication).
512 bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
513 }
514
515 // Serialize the bounding box points.
516 _communicator.allgather(bb_points);
517
518 // Recast the points back into bounding boxes and return.
519 std::vector<BoundingBox> bboxes(bb_points.size());
520 for (unsigned int i = 0; i < bb_points.size(); i++)
521 bboxes[i] = static_cast<BoundingBox>(bb_points[i]);
522
523 // possibly extend bounding boxes
524 extendBoundingBoxes(_bbox_factor, bboxes);
525
526 return bboxes;
527}
MultiAppTransfer::getGlobalSourceAppIndex
unsigned int getGlobalSourceAppIndex(unsigned int i_from) const
Return the global app index from the local index in the "from-multiapp" transfer direction.
Definition MultiAppTransfer.C:664
MultiAppTransfer::transformBoundingBox
static void transformBoundingBox(libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)
Transform a bounding box according to the transformations in the provided coordinate transformation o...
Definition MultiAppTransfer.C:460
MultiAppTransfer::extendBoundingBoxes
void extendBoundingBoxes(const Real factor, std::vector< libMesh::BoundingBox > &bboxes) const
Extends bounding boxes to avoid missing points.
Definition MultiAppTransfer.C:466
MultiAppTransfer::_bbox_factor
Real _bbox_factor
Extend (or contract) bounding box by a factor in all directions Greater than one values of this membe...
Definition MultiAppTransfer.h:181
libMesh::Parallel::Communicator::allgather
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
libMesh::MeshTools::create_local_bounding_box
libMesh::BoundingBox create_local_bounding_box(const MeshBase &mesh)

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

◆ getFromBoundingBoxes() [2/2]

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

Definition at line 530 of file MultiAppTransfer.C.

531{
532 std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
533 const Real min_r = std::numeric_limits<Real>::lowest();
534 const Real max_r = std::numeric_limits<Real>::max();
535
536 for (unsigned int i = 0; i < _from_meshes.size(); i++)
537 {
538
539 Point min(max_r, max_r, max_r);
540 Point max(min_r, min_r, min_r);
541 bool at_least_one = false;
542
543 // TODO: Factor this into mesh_tools after adding new boundary bounding box routine.
544 const ConstBndNodeRange & bnd_nodes = *_from_meshes[i]->getBoundaryNodeRange();
545 for (const auto & bnode : bnd_nodes)
546 {
547 if (bnode->_bnd_id == boundary_id &&
548 bnode->_node->processor_id() == _from_meshes[i]->processor_id())
549 {
550 at_least_one = true;
551 const auto & node = *bnode->_node;
552 for (const auto i : make_range(Moose::dim))
553 {
554 min(i) = std::min(min(i), node(i));
555 max(i) = std::max(max(i), node(i));
556 }
557 }
558 }
559
560 BoundingBox bbox(min, max);
561 if (!at_least_one)
562 bbox.min() = max; // If we didn't hit any nodes, this will be _the_ minimum bbox
563 else
564 {
565 // Translate the bounding box to the from domain's position. We may have rotations so we must
566 // be careful in constructing the new min and max (first and second)
567 const auto from_global_num = getGlobalSourceAppIndex(i);
568 transformBoundingBox(bbox, *_from_transforms[from_global_num]);
569 }
570
571 // Cast the bounding box into a pair of points (so it can be put through
572 // MPI communication).
573 bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
574 }
575
576 // Serialize the bounding box points.
577 _communicator.allgather(bb_points);
578
579 // Recast the points back into bounding boxes and return.
580 std::vector<BoundingBox> bboxes(bb_points.size());
581 for (unsigned int i = 0; i < bb_points.size(); i++)
582 bboxes[i] = static_cast<BoundingBox>(bb_points[i]);
583
584 // possibly extend bounding boxes
585 extendBoundingBoxes(_bbox_factor, bboxes);
586
587 return bboxes;
588}
dim
unsigned int dim
CompileTimeDerivatives::max
auto max(const L &left, const R &right)
Definition CompileTimeDerivatives.h:276
CompileTimeDerivatives::min
auto min(const L &left, const R &right)
Definition CompileTimeDerivatives.h:269
Moose
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Definition SetAdaptivityOptionsAction.h:15

◆ getFromMultiApp()

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

Get the MultiApp to transfer data from.

Definition at line 65 of file MultiAppTransfer.h.

66 {
67 if (!_from_multi_app)
68 mooseError(
69 "A from_multiapp was requested but is unavailable. Check the from_multi_app parameter");
70 else
71 return _from_multi_app;
72 }

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

◆ getFromMultiAppInfo()

void MultiAppTransfer::getFromMultiAppInfo ( )
privateinherited

Definition at line 451 of file MultiAppTransfer.C.

452{
453 if (!_from_multi_app)
454 mooseError("There is no from_multiapp to get info from");
455
456 fillInfo(*_from_multi_app, _from_local2global_map, _from_problems, _from_positions);
457}

Referenced by MultiAppTransfer::getAppInfo().

◆ 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 90 of file MultiAppTransfer.h.

91 {
92 if (_from_multi_app)
93 return _from_multi_app->name();
94 else
95 return "Parent";
96 }

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

592{
593 std::vector<unsigned int> froms_per_proc;
594 if (_to_multi_app)
595 froms_per_proc.resize(n_processors(), 1);
596 if (_from_multi_app)
597 {
598 froms_per_proc.resize(n_processors());
599 _communicator.allgather(_from_multi_app->numLocalApps(), froms_per_proc);
600 }
601 return froms_per_proc;
602}
libMesh::ParallelObject::n_processors
processor_id_type n_processors() const

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

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

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

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

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldTransfer::acceptPointMeshDivision(), MultiAppGeneralFieldFunctorTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldKDTreeTransferBase::checkRestrictionsForSource(), MultiAppGeneralFieldKDTreeTransferBase::evaluateNearestNodeFromKDTrees(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppProjectionTransfer::execute(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppTransfer::getPointInSourceAppFrame(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), and MultiAppGeneralFieldTransfer::initialSetup().

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

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

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

◆ getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const
inlineinherited
Returns
The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

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

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

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

Definition at line 167 of file MooseBase.C.

168{
169 if (const auto hit_node = params.getHitNode())
170 if (!hit_node->isRoot())
171 return hit_node;
172 return nullptr;
173}
InputParameters::getHitNode
const hit::Node * getHitNode(const std::string &param) const
Definition InputParameters.C:1627

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

681{
682 return _current_direction == TO_MULTIAPP
683 ? 0
684 : _from_local2global_map[i_from] - _from_local2global_map[0];
685}

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const
inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

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

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

49 {
50 if (_from_multi_app && _to_multi_app && _from_multi_app != _to_multi_app)
51 mooseError("Unclear which app you want to retrieve from Transfer ", name());
52 else if (_from_multi_app)
53 return _from_multi_app;
54 else if (_to_multi_app)
55 return _to_multi_app;
56 else if (_multi_app)
57 return _multi_app;
58 else
59 mooseError("Should not get here, there should be a multiapp");
60 }

Referenced by MultiAppCloneReporterTransfer::initialSetup().

◆ getParam() [1/2]

template<typename T >
const T & MooseBase::getParam ( const std::string &  name) const
inherited

Retrieve a parameter for the object.

Parameters
nameThe name of the parameter
Returns
The value of the parameter

Definition at line 406 of file MooseBase.h.

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

Referenced by CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), BlockDeletionGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FileMeshGenerator::generate(), MeshExtruderGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), XYDelaunayGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), AdvancedOutput::init(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribExecutionOrderGroup::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), PetscOutput::solveSetup(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

◆ getParam() [2/2]

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

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

Parameters
param1The name of first parameter
param2The name of second parameter
Returns
Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

◆ getPointInSourceAppFrame()

Point MultiAppTransfer::getPointInSourceAppFrame ( const Point &  p,
unsigned int  local_i_from,
const std::string &  phase 
) const
protectedinherited

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

Parameters
pthe point in the reference frame
local_i_fromthe local source problem index
phasethe 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 source app frame

Definition at line 647 of file MultiAppTransfer.C.

650{
651 return mapBackWithoutCollapsing(
652 *_from_transforms[getGlobalSourceAppIndex(local_i_from)], p, phase);
653}
MultiAppTransfer::mapBackWithoutCollapsing
Point mapBackWithoutCollapsing(MultiAppCoordTransform &transform, const Point &p, const std::string &phase) const
Shared implementation for getPointInSourceAppFrame / getPointInTargetAppFrame.
Definition MultiAppTransfer.C:627

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldKDTreeTransferBase::checkRestrictionsForSource(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), MultiAppGeneralFieldFunctorTransfer::evaluateValues(), MultiAppProjectionTransfer::execute(), MultiAppGeneralFieldKDTreeTransferBase::getPointInSourceKDTreeFrame(), and MultiAppShapeEvaluationTransfer::transferVariable().

◆ 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
pthe point in the reference frame
local_i_tothe local target problem into
phasethe 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 656 of file MultiAppTransfer.C.

659{
660 return mapBackWithoutCollapsing(*_to_transforms[getGlobalTargetAppIndex(local_i_to)], p, phase);
661}
MultiAppTransfer::getGlobalTargetAppIndex
unsigned int getGlobalTargetAppIndex(unsigned int i_to) const
Return the global app index from the local index in the "to-multiapp" transfer direction.
Definition MultiAppTransfer.C:672

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

◆ getRenamedParam()

template<typename T >
const T & MooseBase::getRenamedParam ( const std::string &  old_name,
const std::string &  new_name 
) const
inherited

Retrieve a renamed parameter for the object.

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

Parameters
old_namethe old name for the parameter
new_namethe new name for the parameter

Definition at line 420 of file MooseBase.h.

421{
422 // Most important: accept new parameter
423 if (isParamSetByUser(new_name) && !isParamValid(old_name))
424 return getParam<T>(new_name);
425 // Second most: accept old parameter
426 if (isParamValid(old_name) && !isParamSetByUser(new_name))
427 return getParam<T>(old_name);
428 // Third most: accept default for new parameter
429 if (isParamValid(new_name) && !isParamValid(old_name))
430 return getParam<T>(new_name);
431 // Refuse: no default, no value passed
432 if (!isParamValid(old_name) && !isParamValid(new_name))
433 mooseError("parameter '" + new_name +
434 "' is being retrieved without being set.\nDid you misspell it?");
435 // Refuse: both old and new parameters set by user
436 else
437 mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
438 old_name + "'");
439}
MooseBase::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Definition MooseBase.h:205

◆ 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_nameThe name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

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

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

71{
72 try
73 {
74 return shared_from_this();
75 }
76 catch (std::bad_weak_ptr &)
77 {
78 mooseError(not_shared_error);
79 }
80}

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

◆ getSharedPtr() [2/2]

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

Definition at line 83 of file MooseObject.C.

84{
85 try
86 {
87 return shared_from_this();
88 }
89 catch (std::bad_weak_ptr &)
90 {
91 mooseError(not_shared_error);
92 }
93}

◆ getToMultiApp()

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

Get the MultiApp to transfer data to.

Definition at line 77 of file MultiAppTransfer.h.

78 {
79 if (!_to_multi_app)
80 mooseError(
81 "A to_multiapp was requested but is unavailable. Check the to_multi_app parameter");
82 else
83 return _to_multi_app;
84 }

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

◆ getToMultiAppInfo()

void MultiAppTransfer::getToMultiAppInfo ( )
privateinherited

Definition at line 442 of file MultiAppTransfer.C.

443{
444 if (!_to_multi_app)
445 mooseError("There is no to_multiapp to get info from");
446
447 fillInfo(*_to_multi_app, _to_local2global_map, _to_problems, _to_positions);
448}

Referenced by MultiAppTransfer::getAppInfo().

◆ 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 102 of file MultiAppTransfer.h.

103 {
104 if (_to_multi_app)
105 return _to_multi_app->name();
106 else
107 return "Parent";
108 }

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

35{ 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.

606{
607 mooseAssert(_to_multi_app, "getTransferVector only works for transfers to multiapps");
608
609 return _to_multi_app->appTransferVector(_to_local2global_map[i_local], var_name);
610}

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

◆ hasBase()

bool MooseBase::hasBase ( ) const
inlineinherited
Returns
Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }
InputParameters::hasBase
bool hasBase() const
Definition InputParameters.C:499

◆ hasBlocks() [1/2]

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

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

Definition at line 584 of file MultiAppUserObjectTransfer.C.

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

Referenced by execute().

◆ hasBlocks() [2/2]

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

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

Parameters
meshThe mesh this transfer is active on
nodeThe node to check

Definition at line 590 of file MultiAppUserObjectTransfer.C.

591{
592 const auto & node_blk_ids = mesh->getNodeBlockIds(*node);
593 std::set<SubdomainID> u;
594 std::set_intersection(_blk_ids.begin(),
595 _blk_ids.end(),
596 node_blk_ids.begin(),
597 node_blk_ids.end(),
598 std::inserter(u, u.begin()));
599 return !u.empty();
600}

◆ hasFromMultiApp()

bool MultiAppTransfer::hasFromMultiApp ( ) const
inlineinherited

Whether the transfer owns a non-null from_multi_app.

Definition at line 113 of file MultiAppTransfer.h.

113{ return !(!_from_multi_app); }

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

◆ hasToMultiApp()

bool MultiAppTransfer::hasToMultiApp ( ) const
inlineinherited

Whether the transfer owns a non-null to_multi_app.

Definition at line 118 of file MultiAppTransfer.h.

118{ return !(!_to_multi_app); }

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

◆ initialSetup()

void MultiAppConservativeTransfer::initialSetup ( )
overridevirtualinherited

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

Reimplemented from MultiAppFieldTransfer.

Reimplemented in MultiAppGeneralFieldFunctorTransfer, MultiAppGeneralFieldKDTreeTransferBase, MultiAppGeneralFieldNearestLocationTransfer, MultiAppGeneralFieldTransfer, and MultiAppProjectionTransfer.

Definition at line 117 of file MultiAppConservativeTransfer.C.

118{
119 MultiAppFieldTransfer::initialSetup();
120 if (_preserve_transfer)
121 {
122 if (_from_postprocessors_to_be_preserved.size() == 1 && _current_direction == TO_MULTIAPP)
123 {
124 FEProblemBase & from_problem = getToMultiApp()->problemBase();
125 auto * pps = dynamic_cast<const NearestPointIntegralVariablePostprocessor *>(
126 &(from_problem.getUserObjectBase(_from_postprocessors_to_be_preserved[0])));
127 if (pps)
128 _use_nearestpoint_pps = true;
129 else
130 {
131 _use_nearestpoint_pps = false;
132 if (getToMultiApp()->numGlobalApps() > 1)
133 mooseError(
134 " You have to specify ",
135 getToMultiApp()->numGlobalApps(),
136 " regular from-postprocessors, or use NearestPointIntegralVariablePostprocessor ");
137 }
138 }
139
140 if (_to_postprocessors_to_be_preserved.size() == 1 && _current_direction == FROM_MULTIAPP)
141 {
142 FEProblemBase & to_problem = getFromMultiApp()->problemBase();
143 auto * pps = dynamic_cast<const NearestPointIntegralVariablePostprocessor *>(
144 &(to_problem.getUserObjectBase(_to_postprocessors_to_be_preserved[0])));
145 if (pps)
146 _use_nearestpoint_pps = true;
147 else
148 {
149 _use_nearestpoint_pps = false;
150 if (getFromMultiApp()->numGlobalApps() > 1)
151 mooseError(
152 " You have to specify ",
153 getFromMultiApp()->numGlobalApps(),
154 " regular to-postprocessors, or use NearestPointIntegralVariablePostprocessor ");
155 }
156 }
157
158 const auto multi_app = hasFromMultiApp() ? getFromMultiApp() : getToMultiApp();
159
160 // Let us check execute_on here. Users need to specify execute_on='transfer' in their input
161 // files for the postprocessors that are used to compute the quantities to conserve in the
162 // Parent app
163 FEProblemBase & parent_problem = multi_app->problemBase();
164 std::vector<PostprocessorName> pps_empty;
165 // PPs for parent app
166 auto & parent_app_pps =
167 _current_direction == TO_MULTIAPP ? pps_empty : _to_postprocessors_to_be_preserved;
168 for (auto & pp : parent_app_pps)
169 {
170 // Get out all execute_on options for parent app source pp
171 auto & execute_on = parent_problem.getUserObjectBase(pp).getExecuteOnEnum();
172 const auto & type = parent_problem.getUserObjectBase(pp).type();
173 // Check if parent app has transfer execute_on
174 if (!execute_on.isValueSet(EXEC_TRANSFER))
175 mooseError(
176 "execute_on='transfer' is required in the conservative transfer for " + type + " '",
177 pp,
178 "' computed in the parent application.\n"
179 "Please add execute_on='transfer' to this postprocessor in the input file.\n"
180 "For a custom postprocessor, make sure that execute_on options are not hardcoded.");
181 }
182
183 // Sub apps
184 for (unsigned int i = 0; i < multi_app->numGlobalApps(); i++)
185 {
186 // If we do not have this app, we skip
187 if (!multi_app->hasLocalApp(i))
188 continue;
189 // Sub problem for
190 FEProblemBase & sub_problem = multi_app->appProblemBase(i);
191 // PPs for this subapp
192 auto & sub_pps =
193 _current_direction == TO_MULTIAPP ? _to_postprocessors_to_be_preserved : pps_empty;
194 for (auto & sub_pp : sub_pps)
195 {
196 // Get out of all execute_on options for sub pp
197 auto & execute_on = sub_problem.getUserObjectBase(sub_pp).getExecuteOnEnum();
198 const auto & type = sub_problem.getUserObjectBase(sub_pp).type();
199 // Check if sub pp has transfer execute_on
200 if (!execute_on.isValueSet(EXEC_TRANSFER))
201 mooseError(
202 "execute_on='transfer' is required in the conservative transfer for " + type + " '",
203 sub_pp,
204 "' in child application '" + multi_app->name() +
205 "'. \n"
206 "Please add execute_on='transfer' to this postprocessor in the input file.\n"
207 "For a custom postprocessor, make sure that execute_on options are not "
208 "hardcoded.");
209 }
210 }
211 }
212}
MultiAppConservativeTransfer::_to_postprocessors_to_be_preserved
std::vector< PostprocessorName > _to_postprocessors_to_be_preserved
Postprocessor evaluates an adjuster for the target physics.
Definition MultiAppConservativeTransfer.h:53
MultiAppConservativeTransfer::_use_nearestpoint_pps
bool _use_nearestpoint_pps
Whether to use a nearest point UserObject to obtain the conservation factor.
Definition MultiAppConservativeTransfer.h:68
MultiAppConservativeTransfer::_from_postprocessors_to_be_preserved
std::vector< PostprocessorName > _from_postprocessors_to_be_preserved
Postprocessor evaluates an adjuster for the source physics.
Definition MultiAppConservativeTransfer.h:51
MultiAppConservativeTransfer::_preserve_transfer
bool _preserve_transfer
If this transfer is going to conserve the physics.
Definition MultiAppConservativeTransfer.h:49
MultiAppFieldTransfer::initialSetup
virtual void initialSetup()
Method called at the beginning of the simulation for checking integrity or doing one-time setup.
Definition MultiAppFieldTransfer.C:35

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

◆ isBoundaryElem()

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

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

Returns
true if the element belongs to the boundary this transfer is restricted to, false otherwise
Parameters
meshThe mesh this transfer is active on
elemThe element to check

Definition at line 612 of file MultiAppUserObjectTransfer.C.

613{
614 for (auto & bid : _bnd_ids)
615 if (mesh->isBoundaryElem(elem->id(), bid))
616 return true;
617 return false;
618}

Referenced by execute().

◆ isBoundaryNode()

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

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

Returns
true if the node belongs to the boundary this transfer is restricted to, false otherwise
Parameters
meshThe mesh this transfer is active on
nodeThe node to check

Definition at line 603 of file MultiAppUserObjectTransfer.C.

604{
605 for (auto & bid : _bnd_ids)
606 if (mesh->isBoundaryNode(node->id(), bid))
607 return true;
608 return false;
609}

Referenced by execute().

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const
inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

63{ return parameters().isKokkosObject(); }
InputParameters::isKokkosObject
bool isKokkosObject() const
Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...
Definition InputParameters.C:433

Referenced by AttribKokkos::initFrom(), BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

◆ isParamSetByUser()

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

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

Parameters
nameThe name of the parameter to test

Definition at line 205 of file MooseBase.h.

206 {
207 return _pars.isParamSetByUser(name);
208 }
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
Definition InputParameters.C:1293

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

◆ isParamValid()

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

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }
InputParameters::isParamValid
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another,...
Definition InputParameters.C:386

Referenced by GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), AddVariableAction::act(), AutoCheckpointAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentJunction::ComponentJunction(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenProblemSolve::EigenProblemSolve(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), 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(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), BlockDeletionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BSplineCurveGenerator::generate(), ConcentricCircleMeshGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshExtruderGenerator::generate(), OrientSurfaceMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), SphereMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), AddPeriodicBCAction::getVariables(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionAux::initialSetup(), SolutionScalarAux::initialSetup(), PIDTransientControl::initialSetup(), ParsedConvergence::initialSetup(), EigenProblemSolve::initialSetup(), MooseParsedFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedVectorFunction::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionIC::initialSetup(), Console::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), PNGOutput::makePNG(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), EqualValueBoundaryConstraint::pickPrimaryNode(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), MooseMesh::prepare(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusIIOrNemesis(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, T >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ 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 DiffusionLHDGDirichletBC, DiffusionLHDGPrescribedGradientBC, ElementAndTraceScalarHDGBC, EqualValueEmbeddedConstraintTempl< is_ad >, ADDiracKernel, DiffusionLHDGKernel, ElementAndTraceScalarHDGKernel, ADArrayKernel, ADKernelTempl< T >, ADArrayNodalKernel, Positions, Times, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< Real >, MooseVariableFE< RealEigenVector >, MooseVariableFE< RealVectorValue >, MooseVariableFE< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and Function.

Definition at line 58 of file SetupInterface.C.

59{
60}

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

◆ mapBackWithoutCollapsing()

Point MultiAppTransfer::mapBackWithoutCollapsing ( MultiAppCoordTransform &  transform,
const Point &  p,
const std::string &  phase 
) const
privateinherited

Shared implementation for getPointInSourceAppFrame / getPointInTargetAppFrame.

Calls transform.mapBack(p), skipping coordinate collapsing when a coordinate system type change is present (the reverse mapping is not uniquely defined in that case).

Definition at line 627 of file MultiAppTransfer.C.

630{
631 if (transform.hasCoordinateSystemTypeChange())
632 {
633 if (!_skip_coordinate_collapsing)
634 mooseInfo(phase + " cannot use the point in the app frame due to the "
635 "non-uniqueness of the coordinate collapsing reverse mapping."
636 " Coordinate collapse is ignored for this operation");
637 transform.skipCoordinateCollapsing(true);
638 const auto pt = transform.mapBack(p);
639 transform.skipCoordinateCollapsing(false);
640 return pt;
641 }
642 else
643 return transform.mapBack(p);
644}
MultiAppCoordTransform::mapBack
libMesh::Point mapBack(const libMesh::Point &point) const
Inverse transform from the reference space to our space.
Definition MooseAppCoordTransform.C:538
MultiAppCoordTransform::skipCoordinateCollapsing
void skipCoordinateCollapsing(bool skip_coordinate_collapsing)
set whether coordinate collapsing operations should be skipped
Definition MooseAppCoordTransform.C:653

Referenced by MultiAppTransfer::getPointInSourceAppFrame(), and MultiAppTransfer::getPointInTargetAppFrame().

◆ messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool  hit_prefix = true) const
inlineinherited
Returns
A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

257 {
258 return messagePrefix(_pars, hit_prefix);
259 }

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

◆ messagePrefix() [2/2]

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

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

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

Definition at line 140 of file MooseBase.C.

141{
142 std::string prefix = "";
143
144 if (hit_prefix)
145 if (const auto node = MooseBase::getHitNode(params))
146 prefix += Moose::hitMessagePrefix(*node);
147
148 // Don't have context without type and name
149 if (!params.isMooseBaseObject())
150 return prefix;
151
152 const auto & name = params.getObjectName();
153 const std::string base = params.hasBase() ? params.getBase() : "object";
154 const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
155 prefix += "The following occurred in the ";
156 if (is_main_app)
157 prefix += "main " + base;
158 else
159 prefix += base;
160 if (base != params.getObjectName() && name.size() && !is_main_app)
161 prefix += " '" + name + "'";
162 prefix += " of type " + params.getObjectType() + ".";
163 return prefix + "\n\n";
164}
AppFactory::main_app_name
static const std::string main_app_name
The name for the "main" moose application.
Definition AppFactory.h:68
InputParameters::isMooseBaseObject
bool isMooseBaseObject() const
Definition InputParameters.C:995
InputParameters::getObjectType
const std::string & getObjectType() const
Definition InputParameters.C:1011
InputParameters::getObjectName
const std::string & getObjectName() const
Definition InputParameters.C:1019
Moose::hitMessagePrefix
std::string hitMessagePrefix(const hit::Node &node)
Get the prefix to be associated with a hit node for a message.
Definition Moose.C:883

◆ mooseDeprecated() [1/2]

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

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

Definition at line 317 of file MooseBase.h.

318 {
319 moose::internal::mooseDeprecatedStream(
320 _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
321 }
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition ConsoleStreamInterface.h:31
moose::internal::mooseDeprecatedStream
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, const bool show_trace, Args &&... args)
Definition MooseError.h:252

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

◆ mooseDeprecated() [2/2]

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

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecatedNoTrace()

template<typename... Args>
void MooseBase::mooseDeprecatedNoTrace ( Args &&...  args) const
inlineinherited

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

Definition at line 327 of file MooseBase.h.

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

◆ mooseDocumentedError()

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

Definition at line 277 of file MooseBase.h.

280 {
281 callMooseError(moose::internal::formatMooseDocumentedError(
282 repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
283 /* with_prefix = */ true);
284 }
moose::internal::formatMooseDocumentedError
std::string formatMooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
Formats a documented error.
Definition MooseError.C:142

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>
void MooseBase::mooseError ( Args &&...  args) const
inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

Referenced by CopyMeshPartitioner::_do_partition(), GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), AdaptivityAction::act(), AddBoundsVectorsAction::act(), AddFVICAction::act(), AddICAction::act(), AddMeshGeneratorAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), AddVectorPostprocessorAction::act(), ChainControlSetupAction::act(), CheckFVBCAction::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), InitProblemAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SplitMeshAction::act(), Action::Action(), AddActionComponentAction::AddActionComponentAction(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), MooseApp::addCapabilityInternal(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), SubProblem::addFunctor(), PhysicsComponentInterface::addInitialConditionsFromComponents(), ComponentJunction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), AddActionComponentAction::addRelationshipManagers(), WebServerControl::addServerAction(), AddVariableAction::addVariable(), SubProblem::addVectorTag(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), MooseVariableBase::allDofIndices(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), MooseApp::attachRelationshipManagers(), MooseApp::attachRelationshipManagers(), FEProblemBase::automaticScaling(), Function::average(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), PiecewiseTabularInterface::buildFromXY(), MooseMesh::buildLowerDMesh(), GeneratedMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), TiledMesh::buildMesh(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), Moose::PeriodicBCHelper::checkPeriodicParams(), Sampler::checkReinitStatus(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Moose::PetscSupport::checkUserProvidedPetscOption(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), MooseMesh::clone(), LibmeshPartitioner::clone(), CombinerGenerator::CombinerGenerator(), MooseVariableFieldBase::componentName(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), MooseVariableFieldBase::computeFaceValues(), TimeStepper::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MaterialBase::computeProperties(), FVFluxBC::computeResidual(), ResidualObject::computeResidualAndJacobian(), TimeStepper::computeStep(), AStableDirk4::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyInternal(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), MooseApp::determineLibtorchDeviceType(), MeshDiagnosticsGenerator::diagnosticsLog(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), FunctorRelationshipManager::dofmap_reinit(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), DistributedRectilinearMeshGenerator::elemId(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), FixedPointSolve::examineFixedPointConvergence(), Eigenvalue::execute(), TransientBase::execute(), WebServerControl::execute(), MooseApp::executeExecutioner(), MultiApp::fillPositions(), MooseApp::finalizeRestore(), Transfer::find_sys(), DiracKernelInfo::findPoint(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), LinearFVBoundaryCondition::functorFaceArg(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), AdvancedExtruderGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), CoarsenBlockGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), DistributedRectilinearMeshGenerator::generate(), ElementOrderConversionGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshCollectionGenerator::generate(), MeshDiagnosticsGenerator::generate(), MeshExtruderGenerator::generate(), MeshRepairGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SmoothMeshGenerator::generate(), SpiralAnnularMeshGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), MooseMesh::getAxisymmetricRadialCoord(), MooseMesh::getBlockConnectedBlocks(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), MooseMesh::getCoarseningMap(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PhysicsBase::getCoupledPhysics(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), SubProblem::getFunctor(), MooseMesh::getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), MaterialPropertyInterface::getKokkosBlockMaterialProperty(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), Material::getMaterialByName(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), DistributedRectilinearMeshGenerator::getNeighbors(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), PlaneIDMeshGenerator::getPlaneID(), PostprocessorInterface::getPostprocessorValueByNameInternal(), ComponentMaterialPropertyInterface::getPropertyValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), MooseObject::getSharedPtr(), MooseObject::getSharedPtr(), PhysicsBase::getSolverSystem(), MooseMesh::getSubdomainBoundaryIds(), TransientBase::getTimeIntegratorNames(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), MultiApp::globalAppToLocal(), Function::gradient(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), TransientBase::incrementStepOrReject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), EigenExecutionerBase::init(), TransientBase::init(), CrankNicolson::init(), ExplicitTimeIntegrator::init(), FixedPointIterationAdaptiveDT::init(), IterationAdaptiveDT::init(), MultiApp::init(), NestedDivision::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SubProblem::initialSetup(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), FullSolveMultiApp::initialSetup(), ExplicitTimeIntegrator::initialSetup(), Function::integral(), InternalSideIndicatorBase::InternalSideIndicatorBase(), EigenExecutionerBase::inversePowerIteration(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LineSearch::lineSearch(), MooseApp::loadLibraryAndDependencies(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), Material::Material(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableBase::MooseVariableBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppTransfer::MultiAppTransfer(), NewmarkBeta::NewmarkBeta(), DistributedRectilinearMeshGenerator::nodeId(), DistributedRectilinearMeshGenerator::numNeighbors(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), MortarNodalGeometryOutput::output(), Output::Output(), MooseApp::outputMachineReadableData(), DistributedRectilinearMeshGenerator::paritionSquarely(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularInterface::PiecewiseTabularInterface(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), ProjectSideSetOntoLevelSetGenerator::pointPairLevelSetInterception(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), ExplicitTVDRK2::postResidual(), ImplicitMidpoint::postResidual(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), LStableDirk4::postResidual(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), FixedPointSolve::printFixedPointConvergenceReason(), MultiApp::readCommandLineArguments(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), ScalarComponentIC::ScalarComponentIC(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), MooseMesh::setGeneralAxisymmetricCoordAxes(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), Split::setup(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SmoothMeshGenerator::SmoothMeshGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), Moose::MFEM::LinearSolverBase::Solve(), TimeIntegrator::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), FullSolveMultiApp::solveStep(), UserObject::spatialPoints(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), MeshRepairGenerator::splitNonConvexPolygons(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), MaterialBase::subdomainSetup(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), Action::timedAct(), Function::timeDerivative(), Function::timeIntegral(), ParsedCurveGenerator::tSectionSpaceDefiner(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), MooseVariableScalar::uDotOld(), MooseBase::uniqueName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), Function::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), AddVariableAction::variableType(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), WebServerControl::WebServerControl(), and MooseApp::writeRestartableMetaData().

◆ mooseErrorNonPrefixed()

template<typename... Args>
void MooseBase::mooseErrorNonPrefixed ( Args &&...  args) const
inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

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

Definition at line 334 of file MooseBase.h.

335 {
336 moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
337 }
moose::internal::mooseInfoStream
void mooseInfoStream(S &oss, Args &&... args)
Definition MooseError.h:245

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

◆ mooseWarning() [1/2]

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

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

300 {
301 moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
302 }
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition MooseError.h:197

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

◆ mooseWarning() [2/2]

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

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

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

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

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

Definition at line 80 of file SolutionInvalidInterface.h.

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

◆ name()

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

Get the name of the class.

Returns
The name of the class

Definition at line 103 of file MooseBase.h.

104 {
105 mooseAssert(_name.size(), "Empty name");
106 return _name;
107 }
MooseBase::_name
const std::string & _name
The name of this class.
Definition MooseBase.h:381

Referenced by AdaptivityAction::act(), AddActionComponentAction::act(), AddElementalFieldAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), CommonOutputAction::act(), CopyNodalVarsAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), SetupResidualDebugAction::act(), SetupTimeIntegratorAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), ElementAndTraceScalarHDGAssemblyHelper::additionalROVariables(), BoundaryIntegralValueConstraint::additionalROVariables(), DiffusionLHDGKernel::additionalROVariables(), ADKernelScalarBase::additionalROVariables(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), InitialConditionWarehouse::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), UserObjectBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), InitialConditionBase::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addQuadratureFunction(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), AddActionComponentAction::addRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), PhysicsBase::addUserObject(), FEProblemBase::addUserObject(), UserObjectBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), InitialConditionBase::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), UserObjectBase::addVectorPostprocessorDependencyHelper(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< OutputType >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), NEML2ModelExecutor::advanceState(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromXY(), MFEMGeometricMultigridSolver::BuildMultigrid(), MooseMesh::buildNodeListFromSideList(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), DefaultNonlinearConvergence::checkConvergence(), ParsedConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), NonlinearSystemBase::checkKernelCoverage(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), FEProblemBase::checkUserObjectNameCollision(), BlockRestrictable::checkVariable(), DomainUserObject::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(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), MeshInfo::declareHelper(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementDamper::ElementDamper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), RestartableDataReporter::execute(), MultiAppGeneralFieldTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), execute(), SideValueSampler::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), NEML2ModelExecutor::fillInputs(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FVFunctionIC::functionName(), FunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), BoundaryDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ManifoldSubdomainGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MooseMesh::getBoundaryString(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), MFEMProblem::getComplexGridFunction(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), UserObjectBase::getDependObjects(), FEProblemBase::getDistribution(), DistributionInterface::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), FEProblemBase::getExecutor(), MooseApp::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVAdvectedInterpolationMethod(), FEProblemBase::getFVFaceInterpolationMethod(), FEProblemBase::getFVInterpolationMethod(), AuxKernelTempl< ComputeValueType >::getGenericMaterialProperty(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), FEProblemBase::getKokkosFunction(), FEProblemBase::getKokkosUserObject(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), AuxKernelTempl< ComputeValueType >::getMaterialProperty(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOlder(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMObject::getMatrixCoefficient(), MFEMObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MFEMProblem::getMFEMObject(), ActionWarehouse::getMooseAppName(), NEML2FEInterpolation::getMOOSEVariable(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MFEMExecutedObject::getRequestedItems(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMObject::getScalarCoefficient(), MFEMObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MFEMExecutedObject::getSuppliedItems(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMObject::getVectorCoefficient(), MFEMObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasDistribution(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), FEProblemBase::hasFVInterpolationMethod(), MeshInfo::hasItem(), MooseApp::hasMeshGenerator(), MFEMProblem::hasMFEMObject(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), AdvancedOutput::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), MeshInfo::initCombinedInfos(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), Console::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), NodalVariableValue::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppGeneralFieldFunctorTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< T >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< OutputType >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), Material::Material(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), NEML2ModelExecutor::meshChanged(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMScalarQuadratureFunction::MFEMScalarQuadratureFunction(), MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< T >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer(), NEML2PreKernel::NEML2PreKernel(), NodalDamper::NodalDamper(), MooseLinearVariableFV< OutputType >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), MeshGenerator::Comparator::operator()(), DOFMapOutput::output(), ProgressOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseFunction::PiecewiseFunction(), MooseApp::possiblyLoadRestartableMetaData(), MFEMExecutedObject::postprocessorDependencyKey(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), FEProblemBase::setAuxKernelParamsAndLog(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), MooseMesh::setSubdomainName(), MooseMesh::setSubdomainName(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), TransientMultiApp::setupApp(), NEML2Action::setupOutputMappings(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), SumPostprocessor::SumPostprocessor(), MFEMPostprocessor::suppliedPostprocessorName(), MFEMVectorPostprocessor::suppliedVectorPostprocessorName(), NEML2FEInterpolation::syncWithMainThread(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< OutputType >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), TransientMultiApp::TransientMultiApp(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVQpFluxBC::uOnGhost(), FVQpFluxBC::uOnUSub(), UserObjectBase::UserObjectBase(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), MeshInfo::validParams(), MFEMExecutedObject::variableDependencyKey(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), MFEMExecutedObject::vectorPostprocessorDependencyKey(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

◆ paramError()

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

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

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

Definition at line 457 of file MooseBase.h.

458{
459 _pars.paramError(param, std::forward<Args>(args)...);
460}
InputParameters::paramError
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available.
Definition InputParameters.h:2511

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), CommonOutputAction::act(), SetupDebugAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayCoupledForce::ArrayCoupledForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayReactionNodalKernelTempl< is_ad >::ArrayReactionNodalKernelTempl(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundaryIntegralValueConstraint::BoundaryIntegralValueConstraint(), BoundaryLinearFVFluxIntegral::BoundaryLinearFVFluxIntegral(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMFESpaceHierarchy::buildHierarchy(), MFEMMesh::buildMesh(), MFEMGeometricMultigridSolver::BuildMultigrid(), TimeSequenceStepperBase::buildSequence(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), checkComponent(), Moose::Kokkos::ParsedObjectBase::checkDuplicateSymbols(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentJunction::ComponentJunction(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), MultiAppGeneralFieldTransfer::correctSolutionVectorValues(), 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(), EigenProblemSolve::EigenProblemSolve(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ElementNormalAux::ElementNormalAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), AdvancedExtruderGenerator::generate(), BlockDeletionGenerator::generate(), BlockToMeshConverterGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryDeletionGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CoarsenBlockGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), UniqueExtraIDMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), BoundaryLayerUtils::generateOffsetPolyline(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MFEMTransient::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), SolutionIC::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), ElementSubdomainModifierBase::initialSetup(), MFEMScalarCoefficientPointValueSampler::initialSetup(), FullSolveMultiApp::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldKDTreeTransferBase::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatReactionTempl< is_ad >::MatReactionTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MeshInfo::MeshInfo(), MFEMComplexSumAux::MFEMComplexSumAux(), MFEMFunctorMaterial::MFEMFunctorMaterial(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MFEMVariable::MFEMVariable(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NEML2PreKernel::NEML2PreKernel(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), NumDOFs::NumDOFs(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), RankTwoTensorFromComponentProperties::RankTwoTensorFromComponentProperties(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusIIOrNemesis(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), CylinderComponent::setupComponent(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupInputMappings(), MultiSystemSolveObject::setupMultiSystemFixedPointRelaxationFactors(), NEML2Action::setupParameterDerivativeMappings(), NEML2Action::setupParameterMappings(), SetupQuadratureAction::SetupQuadratureAction(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), CylinderComponent::translation(), MeshTriangulationUtils::triangulateWithDelaunay(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObjectBase::UserObjectBase(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), MFEMProblem::validateVariableNumericType(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

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

◆ paramInfo()

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

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

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

Definition at line 471 of file MooseBase.h.

472{
473 mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
474}
InputParameters::paramMessage
std::string paramMessage(const std::string &param, Args... args) const
Definition InputParameters.h:2502

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

◆ paramWarning() [1/2]

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

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

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

Definition at line 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

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

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )
inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

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

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

◆ performAdjustment()

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

Definition at line 526 of file MultiAppConservativeTransfer.C.

528{
529 if (from * to > 0)
530 return true;
531 else if (_allow_skipped_adjustment)
532 return false;
533 else
534 mooseError("Adjustment postprocessors from: ",
535 from,
536 " to: ",
537 to,
538 " must both have the same sign and be different from 0");
539}
MultiAppConservativeTransfer::_allow_skipped_adjustment
bool _allow_skipped_adjustment
Whether the adjustment may be skipped when the postprocessor values are 0 / of different signs.
Definition MultiAppConservativeTransfer.h:70

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

◆ possibleDirections()

static std::string Transfer::possibleDirections ( )
inlinestaticinherited

Used to construct InputParameters.

Definition at line 76 of file Transfer.h.

76{ return "to_multiapp from_multiapp between_multiapp"; }

Referenced by Transfer::validParams().

◆ postExecute()

void MultiAppConservativeTransfer::postExecute ( )
virtualinherited

Add some extra work if necessary after execute().

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

Reimplemented in MultiAppGeneralFieldTransfer.

Definition at line 215 of file MultiAppConservativeTransfer.C.

216{
217 if (_preserve_transfer)
218 {
219 TIME_SECTION("MultiAppConservativeTransfer::execute()",
220 5,
221 "Post transfer to preserve postprocessor values");
222
223 if (_current_direction == TO_MULTIAPP)
224 {
225 FEProblemBase & from_problem = getToMultiApp()->problemBase();
226 if (_use_nearestpoint_pps)
227 from_problem.computeUserObjectByName(
228 EXEC_TRANSFER, Moose::POST_AUX, _from_postprocessors_to_be_preserved[0]);
229
230 for (unsigned int i = 0; i < getToMultiApp()->numGlobalApps(); i++)
231 if (getToMultiApp()->hasLocalApp(i))
232 {
233 if (_use_nearestpoint_pps)
234 adjustTransferredSolutionNearestPoint(i,
235 &from_problem,
236 _from_postprocessors_to_be_preserved[0],
237 getToMultiApp()->appProblemBase(i),
238 _to_postprocessors_to_be_preserved[0]);
239 else
240 adjustTransferredSolution(&from_problem,
241 _from_postprocessors_to_be_preserved[i],
242 getToMultiApp()->appProblemBase(i),
243 _to_postprocessors_to_be_preserved[0]);
244 }
245 }
246
247 else if (_current_direction == FROM_MULTIAPP)
248 {
249 FEProblemBase & to_problem = getFromMultiApp()->problemBase();
250 if (_use_nearestpoint_pps)
251 to_problem.computeUserObjectByName(
252 EXEC_TRANSFER, Moose::POST_AUX, _to_postprocessors_to_be_preserved[0]);
253
254 for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
255 {
256 if (_use_nearestpoint_pps)
257 adjustTransferredSolutionNearestPoint(
258 i,
259 getFromMultiApp()->hasLocalApp(i) ? &getFromMultiApp()->appProblemBase(i) : nullptr,
260 _from_postprocessors_to_be_preserved[0],
261 to_problem,
262 _to_postprocessors_to_be_preserved[0]);
263 else
264 adjustTransferredSolution(
265 getFromMultiApp()->hasLocalApp(i) ? &getFromMultiApp()->appProblemBase(i) : nullptr,
266 _from_postprocessors_to_be_preserved[0],
267 to_problem,
268 _to_postprocessors_to_be_preserved[i]);
269 }
270
271 // Compute the to-postprocessor again so that it has the right value with the updated solution
272 if (_use_nearestpoint_pps)
273 to_problem.computeUserObjectByName(
274 EXEC_TRANSFER, Moose::POST_AUX, _to_postprocessors_to_be_preserved[0]);
275 }
276 }
277}
MultiAppConservativeTransfer::adjustTransferredSolution
void adjustTransferredSolution(FEProblemBase *from_problem, PostprocessorName &from_postprocessor, FEProblemBase &to_problem, PostprocessorName &to_postprocessor)
Definition MultiAppConservativeTransfer.C:398
MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint
void adjustTransferredSolutionNearestPoint(unsigned int i, FEProblemBase *from_problem, PostprocessorName &from_postprocessor, FEProblemBase &to_problem, PostprocessorName &to_postprocessor)
Definition MultiAppConservativeTransfer.C:280

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

◆ queryParam()

template<typename T >
const T * MooseBase::queryParam ( const std::string &  name) const
inherited

Query a parameter for the object.

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

Parameters
nameThe name of the parameter
Returns
A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

414{
415 return _pars.queryParam<T>(name);
416}
InputParameters::queryParam
const T * queryParam(const std::string &name) const
Query a parameter.
Definition InputParameters.h:2311

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

◆ registerInvalidSolutionInternal()

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

Definition at line 55 of file SolutionInvalidInterface.C.

57{
58 return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
59 _si_moose_base.type(), message, warning);
60}
moose::internal::SolutionInvalidityRegistry::registerInvalidity
InvalidSolutionID registerInvalidity(const std::string &object_type, const std::string &message, const bool warning)
Call to register an invalid calculation.
Definition SolutionInvalidityRegistry.C:33

◆ registerRestartableDataOnApp()

RestartableDataValue & Restartable::registerRestartableDataOnApp ( std::unique_ptr< RestartableDataValue >  data,
THREAD_ID  tid 
) const
privateinherited

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

65{
66 return _restartable_app.registerRestartableData(
67 std::move(data), tid, _restartable_read_only, _metaname);
68}
MooseApp::registerRestartableData
RestartableDataValue & registerRestartableData(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
Definition MooseApp.C:2449
Restartable::_metaname
const RestartableDataMapName _metaname
Restartable metadata name.
Definition Restartable.h:247
Restartable::_restartable_read_only
const bool _restartable_read_only
Flag for toggling read only status (see ReporterData)
Definition Restartable.h:243
Restartable::_restartable_app
MooseApp & _restartable_app
Reference to the application.
Definition Restartable.h:234

Referenced by Restartable::declareRestartableDataHelper().

◆ registerRestartableNameWithFilterOnApp()

void Restartable::registerRestartableNameWithFilterOnApp ( const std::string &  name,
Moose::RESTARTABLE_FILTER  filter 
)
privateinherited

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

73{
74 _restartable_app.registerRestartableNameWithFilter(name, filter);
75}
MooseApp::registerRestartableNameWithFilter
void registerRestartableNameWithFilter(const std::string &name, Moose::RESTARTABLE_FILTER filter)
NOTE: This is an internal function meant for MOOSE use only!
Definition MooseApp.C:1701

Referenced by Restartable::declareRecoverableData().

◆ registerTimedSection() [1/2]

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

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
Returns
The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

63{
64 const auto timed_section_name = timedSectionName(section_name);
65 if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
66 return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
67 else
68 return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
69}
PerfGraphInterface::timedSectionName
std::string timedSectionName(const std::string &section_name) const
Definition PerfGraphInterface.C:55
moose::internal::PerfGraphRegistry::sectionID
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID @section_name The name of the section.
Definition PerfGraphRegistry.h:111
moose::internal::PerfGraphRegistry::registerSection
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
Definition PerfGraphRegistry.C:34
moose::internal::getPerfGraphRegistry
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.
Definition PerfGraphRegistry.C:20

◆ registerTimedSection() [2/2]

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

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
live_messageThe message to be printed to the screen during execution
print_dotsWhether or not progress dots should be printed for this section
Returns
The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

76{
77 const auto timed_section_name = timedSectionName(section_name);
78 if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
79 return moose::internal::getPerfGraphRegistry().registerSection(
80 timedSectionName(section_name), level, live_message, print_dots);
81 else
82 return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
83}

◆ 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 NodeFaceConstraint, Positions, Times, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< Real >, MooseVariableFE< RealEigenVector >, MooseVariableFE< RealVectorValue >, MooseVariableFE< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and Function.

Definition at line 63 of file SetupInterface.C.

64{
65}

Referenced by MooseVariableField< OutputType >::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 78 of file Restartable.C.

79{
80 return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
81}
Restartable::_restartable_system_name
const std::string _restartable_system_name
The system name this object is in.
Definition Restartable.h:237

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

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

90 {
91 _current_direction = direction;
92 _direction = direction;
93 }
Transfer::direction
MooseEnum direction()
Definition Transfer.h:84

Referenced by FEProblemBase::execMultiAppTransfers().

◆ 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 Material, MaterialBase, GeneralUserObject, NodalUserObject, ThreadedGeneralUserObject, Constraint, Moose::Kokkos::AuxKernel, Moose::Kokkos::MaterialBase, and Moose::Kokkos::UserObject.

Definition at line 68 of file SetupInterface.C.

69{
70}

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name) const
protectedinherited
Returns
The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

56{
57 return _prefix.empty() ? "" : (_prefix + "::") + section_name;
58}
PerfGraphInterface::_prefix
const std::string _prefix
A prefix to use for all sections.
Definition PerfGraphInterface.h:138

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

◆ timestepSetup()

void SetupInterface::timestepSetup ( )
virtualinherited

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

Reimplemented in VectorPostprocessorVisualizationAux, EqualValueEmbeddedConstraintTempl< is_ad >, PIDTransientControl, Function, ElementSubdomainModifierBase, Console, JSONOutput, Positions, MemoryUsage, NumNonlinearIterations, Times, SolutionUserObjectBase, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and VectorMemoryUsage.

Definition at line 53 of file SetupInterface.C.

54{
55}

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

◆ transformBoundingBox()

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

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

Definition at line 460 of file MultiAppTransfer.C.

461{
462 MultiApp::transformBoundingBox(box, transform);
463}
MultiApp::transformBoundingBox
static void transformBoundingBox(libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)
Transform a bounding box according to the transformations in the provided coordinate transformation o...
Definition MultiApp.C:902

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

◆ type()

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

Get the type of this class.

Returns
the name of the type of this class

Definition at line 93 of file MooseBase.h.

94 {
95 mooseAssert(_type.size(), "Empty type");
96 return _type;
97 }
MooseBase::_type
const std::string & _type
The type of this class.
Definition MooseBase.h:378

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

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const
inherited

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

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

Definition at line 57 of file MooseBase.C.

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

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

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const
inherited
Returns
The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

70{
71 if (!_pars.have_parameter<std::string>(unique_name_param))
72 mooseError("uniqueName(): Object does not have a unique name");
73 return MooseObjectName(_pars.get<std::string>(unique_name_param));
74}
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition InputParameters.h:2402
MooseBase::unique_name_param
static const std::string unique_name_param
The name of the parameter that contains the unique object name.
Definition MooseBase.h:57
MooseObjectName
A class for storing the names of MooseObject by tag and object name.
Definition MooseObjectName.h:41

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

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string &  parameter_name) const
inherited
Returns
The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

64{
65 return MooseObjectParameterName(getBase(), name(), parameter_name);
66}
MooseBase::getBase
const std::string & getBase() const
Definition MooseBase.h:147

◆ usesMooseAppCoordTransform()

bool MultiAppUserObjectTransfer::usesMooseAppCoordTransform ( ) const
inlineoverrideprivatevirtual

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

whether it uses the MooseAppCoordTransform object

Reimplemented from MultiAppTransfer.

Definition at line 103 of file MultiAppUserObjectTransfer.h.

103{ return true; }

◆ validParams()

InputParameters MultiAppUserObjectTransfer::validParams ( )
static

Definition at line 33 of file MultiAppUserObjectTransfer.C.

34{
35 InputParameters params = MultiAppConservativeTransfer::validParams();
36 // MultiAppUserObjectTransfer does not need source variable since it query values from user
37 // objects
38 params.set<std::vector<VariableName>>("source_variable") = std::vector<VariableName>{};
39 params.suppressParameter<std::vector<VariableName>>("source_variable");
40 params.addRequiredParam<UserObjectName>(
41 "user_object",
42 "The UserObject you want to transfer values from. Note: This might be a "
43 "UserObject from your MultiApp's input file!");
44 params.addParam<bool>("all_parent_nodes_contained_in_sub_app",
45 false,
46 "Set to true if every parent app node is mapped to a distinct point on one "
47 "of the subApps during a transfer from sub App to Parent App. If parent app"
48 " node cannot be found within bounding boxes of any of the subApps, an "
49 " error is generated.");
50 params.addDeprecatedParam<bool>(
51 "all_master_nodes_contained_in_sub_app",
52 "Set to true if every parent app node is mapped to a distinct point on one "
53 "of the subApps during a transfer from sub App to Parent App. If parent app"
54 " node cannot be found within bounding boxes of any of the subApps, an "
55 " error is generated.",
56 "all_master_nodes_contained_in_sub_app is deprecated. Use "
57 "all_parent_nodes_contained_in_sub_app");
58 params.addParam<bool>(
59 "skip_bounding_box_check",
60 false,
61 "Skip the check if the to_elem is within the bounding box of the from_app.");
62 params.addParam<std::vector<SubdomainName>>(
63 "block", "The block we are transferring to (if not specified, whole domain is used).");
64 params.addParam<std::vector<BoundaryName>>(
65 "boundary",
66 "The boundary we are transferring to (if not specified, whole domain is used unless 'block' "
67 "parameter is used).");
68
69 params.addClassDescription(
70 "Samples a variable's value in the Parent app domain at the point where the MultiApp is and "
71 "copies that value into a post-processor in the MultiApp");
72
73 params.addParam<bool>("nearest_sub_app",
74 false,
75 "When True, a from_multiapp transfer will work by finding the nearest "
76 "(using the `location`) sub-app and query that for the value to transfer");
77 MultiAppTransfer::addUserObjectExecutionCheckParam(params);
78
79 return params;
80}
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.
Definition InputParameters.h:68
InputParameters::suppressParameter
void suppressParameter(const std::string &name)
This method suppresses an inherited parameter so that it isn't required or valid in the derived class...
Definition InputParameters.h:2123
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
Definition InputParameters.h:1806
InputParameters::addDeprecatedParam
void addDeprecatedParam(const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)
Definition InputParameters.h:2170
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump.
Definition InputParameters.C:81
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition InputParameters.h:1596
MultiAppTransfer::addUserObjectExecutionCheckParam
static void addUserObjectExecutionCheckParam(InputParameters &params)
Add the execution order check parameter (to skip the warning if needed)
Definition MultiAppTransfer.C:86

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

199{
200 bool variable_found = false;
201 bool has_an_app = false;
202
203 // Check the from_multi_app for the variable
204 if (is_from_multiapp && _from_multi_app)
205 for (unsigned int i = 0; i < _from_multi_app->numGlobalApps(); i++)
206 if (_from_multi_app->hasLocalApp(i))
207 {
208 has_an_app = true;
209 if (_from_multi_app->appProblemBase(i).hasVariable(var_name))
210 variable_found = true;
211 }
212
213 // Check the to_multi_app for the variable
214 if (!is_from_multiapp && _to_multi_app)
215 for (unsigned int i = 0; i < _to_multi_app->numGlobalApps(); i++)
216 if (_to_multi_app->hasLocalApp(i))
217 {
218 has_an_app = true;
219 if (_to_multi_app->appProblemBase(i).hasVariable(var_name))
220 variable_found = true;
221 }
222
223 if (!variable_found && has_an_app)
224 mooseError("Cannot find variable ", var_name, " for ", name(), " Transfer");
225}

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

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

◆ _all_parent_nodes_contained_in_sub_app

const bool MultiAppUserObjectTransfer::_all_parent_nodes_contained_in_sub_app
protected

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

Definition at line 94 of file MultiAppUserObjectTransfer.h.

Referenced by execute().

◆ _allow_skipped_adjustment

bool MultiAppConservativeTransfer::_allow_skipped_adjustment
privateinherited

Whether the adjustment may be skipped when the postprocessor values are 0 / of different signs.

Definition at line 70 of file MultiAppConservativeTransfer.h.

Referenced by MultiAppConservativeTransfer::performAdjustment().

◆ _app

MooseApp& MooseBase::_app
protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), FEProblemBase::checkProblemIntegrity(), LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), PetscExternalPartitioner::clone(), RandomPartitioner::clone(), SingleRankPartitioner::clone(), ElementPointNeighborLayers::clone(), ElementSideNeighborLayers::clone(), GhostAllPointNeighbors::clone(), GhostBoundary::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), GhostPrimaryFace::clone(), ProxyRelationshipManager::clone(), RedistributeProperties::clone(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianSys(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualSys(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), Control::Control(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MultiApp::createApps(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), PseudoTimestep::execute(), IterationInfo::execute(), EigenProblem::execute(), Executioner::Executioner(), Executioner::Executioner(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), NEML2Assembly::finalize(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MeshGenerator::getCSGBaseByName(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), NumFixedPointIterations::getValue(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), Eigenvalue::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), FEProblemBase::init(), CompositionDT::init(), SubProblem::initialSetup(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), TimePeriod::initialSetup(), EigenProblemSolve::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::meshChanged(), MeshGenerator::MeshGenerator(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), Checkpoint::output(), Exodus::output(), Nemesis::output(), PerfGraphOutput::output(), Tecplot::output(), MortarNodalGeometryOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), JSONOutput::outputReporters(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), JSONOutput::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), FEProblemBase::projectSolution(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), FixedPointSolve::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), SubProblem::timestepSetup(), PIDTransientControl::timestepSetup(), FEProblemBase::timestepSetup(), TransientBase::TransientBase(), MooseMesh::update(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), and FEProblemBase::~FEProblemBase().

◆ _bbox_factor

Real MultiAppTransfer::_bbox_factor
protectedinherited

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

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

Definition at line 181 of file MultiAppTransfer.h.

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

◆ _blk_ids

std::set<SubdomainID> MultiAppUserObjectTransfer::_blk_ids
private

Set of block ids this transfer is restricted to.

Definition at line 106 of file MultiAppUserObjectTransfer.h.

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

◆ _bnd_ids

std::set<BoundaryID> MultiAppUserObjectTransfer::_bnd_ids
private

Set of the boundary ids.

Definition at line 109 of file MultiAppUserObjectTransfer.h.

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

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

◆ _current_direction

MooseEnum Transfer::_current_direction
protectedinherited

Definition at line 106 of file Transfer.h.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), Transfer::currentDirection(), MFEMMultiAppTransfer::execute(), MultiAppCloneReporterTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeneralFieldFunctorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppReporterTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getGlobalSourceAppIndex(), MultiAppTransfer::getGlobalTargetAppIndex(), MultiAppTransfer::getLocalSourceAppIndex(), MultiAppFieldTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), 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 86 of file SetupInterface.h.

Referenced by PseudoTimestep::execute().

◆ _direction

MooseEnum Transfer::_direction
protectedinherited

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

Definition at line 105 of file Transfer.h.

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

◆ _directions

MultiMooseEnum Transfer::_directions
protectedinherited

The directions this Transfer is to be executed on.

Definition at line 110 of file Transfer.h.

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

◆ _displaced_source_mesh

bool MultiAppTransfer::_displaced_source_mesh
protectedinherited

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

Definition at line 169 of file MultiAppTransfer.h.

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

◆ _displaced_target_mesh

bool MultiAppTransfer::_displaced_target_mesh
protectedinherited

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

Definition at line 171 of file MultiAppTransfer.h.

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

◆ _empty_execute_enum

ExecFlagEnum SetupInterface::_empty_execute_enum
privateinherited

Empty ExecFlagEnum for the case when the "execute_on" parameter is not included.

This is private because others should not be messing with it.

Definition at line 79 of file SetupInterface.h.

Referenced by SetupInterface::SetupInterface().

◆ _enabled

const bool& MooseObject::_enabled
protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _execute_enum

const ExecFlagEnum& SetupInterface::_execute_enum
protectedinherited

Execute settings for this object.

Definition at line 83 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(), AdaptivityAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), AddPeriodicBCAction::act(), AutoCheckpointAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupResidualDebugAction::act(), SetupTimeStepperAction::act(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getFactory(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _fe_problem

FEProblemBase& Transfer::_fe_problem
protectedinherited

Definition at line 97 of file Transfer.h.

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

◆ _from_es

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

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

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

◆ _from_meshes

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

Definition at line 158 of file MultiAppTransfer.h.

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

◆ _from_moose_app_transform

std::unique_ptr<MooseAppCoordTransform> MultiAppTransfer::_from_moose_app_transform
privateinherited

The moose coordinate transformation object describing rotations, scaling, and coordinate system of the from application.

Definition at line 328 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::getAppInfo().

◆ _from_multi_app

std::shared_ptr<MultiApp> MultiAppTransfer::_from_multi_app
privateinherited

The MultiApps this Transfer is transferring data to or from.

Definition at line 320 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::checkMultiAppExecuteOn(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), MultiAppTransfer::getFromName(), MultiAppTransfer::getFromsPerProc(), MultiAppTransfer::getMultiApp(), MultiAppTransfer::hasFromMultiApp(), MultiAppTransfer::initialSetup(), MultiAppTransfer::MultiAppTransfer(), and MultiAppTransfer::variableIntegrityCheck().

◆ _from_positions

std::vector<Point> MultiAppTransfer::_from_positions
protectedinherited

Definition at line 160 of file MultiAppTransfer.h.

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

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

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

◆ _from_transforms

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

Definition at line 162 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldFunctorTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldKDTreeTransferBase::evaluateNearestNodeFromKDTrees(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), execute(), findSubAppToTransferFrom(), MFEMMultiAppTransfer::getActiveFromTransform(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppTransfer::getPointInSourceAppFrame(), and MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes().

◆ _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 MultiAppGeometricInterpolationTransfer::execute(), MultiAppNearestNodeTransfer::execute(), and MultiAppProjectionTransfer::execute().

◆ _from_var_names

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

Name of variables transferring from.

Definition at line 40 of file MultiAppConservativeTransfer.h.

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

◆ _metaname

const RestartableDataMapName Restartable::_metaname
privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _multi_app

std::shared_ptr<MultiApp> MultiAppTransfer::_multi_app
protectedinherited

Deprecated class attribute for compatibility with the apps.

Definition at line 151 of file MultiAppTransfer.h.

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

◆ _name

const std::string& MooseBase::_name
protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

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

◆ _nearest_sub_app

const bool& MultiAppUserObjectTransfer::_nearest_sub_app
protected

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

Definition at line 100 of file MultiAppUserObjectTransfer.h.

Referenced by findSubAppToTransferFrom().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent
privateinherited

Definition at line 58 of file DataFileInterface.h.

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

◆ _pars

const InputParameters& MooseBase::_pars
protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

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

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app
protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _prefix

const std::string PerfGraphInterface::_prefix
protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _preserve_transfer

bool MultiAppConservativeTransfer::_preserve_transfer
protectedinherited

If this transfer is going to conserve the physics.

Definition at line 49 of file MultiAppConservativeTransfer.h.

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

◆ _restartable_app

MooseApp& Restartable::_restartable_app
protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

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

◆ _restartable_name

std::string Restartable::_restartable_name
privateinherited

The name of the object.

Definition at line 250 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithObjectNameWithContext(), and Restartable::restartableName().

◆ _restartable_read_only

const bool Restartable::_restartable_read_only
protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 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 237 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 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base
privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

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

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem
privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _skip_bbox_check

const bool MultiAppUserObjectTransfer::_skip_bbox_check
protected

whether to check the bounding box check or not

Definition at line 97 of file MultiAppUserObjectTransfer.h.

Referenced by findSubAppToTransferFrom().

◆ _skip_coordinate_collapsing

const bool MultiAppTransfer::_skip_coordinate_collapsing
protectedinherited

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

Definition at line 166 of file MultiAppTransfer.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), MultiAppGeneralFieldKDTreeTransferBase::evaluateNearestNodeFromKDTrees(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::mapBackWithoutCollapsing(), and MultiAppGeneralFieldTransfer::outputValueConflicts().

◆ _subproblem

SubProblem& Transfer::_subproblem
protectedinherited

Definition at line 96 of file Transfer.h.

◆ _sys

SystemBase& Transfer::_sys
protectedinherited

Definition at line 98 of file Transfer.h.

◆ _tid

THREAD_ID Transfer::_tid
protectedinherited

Definition at line 100 of file Transfer.h.

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

◆ _to_es

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

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

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

◆ _to_meshes

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

Definition at line 157 of file MultiAppTransfer.h.

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

◆ _to_moose_app_transform

std::unique_ptr<MooseAppCoordTransform> MultiAppTransfer::_to_moose_app_transform
privateinherited

The moose coordinate transformation object describing rotations, scaling, and coordinate system of the to application.

Definition at line 332 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::getAppInfo().

◆ _to_multi_app

std::shared_ptr<MultiApp> MultiAppTransfer::_to_multi_app
privateinherited

Definition at line 321 of file MultiAppTransfer.h.

Referenced by MultiAppTransfer::checkMultiAppExecuteOn(), MultiAppTransfer::getAppInfo(), MultiAppTransfer::getFromsPerProc(), MultiAppTransfer::getMultiApp(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MultiAppTransfer::getToName(), MultiAppTransfer::getTransferVector(), MultiAppTransfer::hasToMultiApp(), MultiAppTransfer::initialSetup(), MultiAppTransfer::MultiAppTransfer(), and MultiAppTransfer::variableIntegrityCheck().

◆ _to_positions

std::vector<Point> MultiAppTransfer::_to_positions
protectedinherited

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

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

◆ _to_transforms

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

Definition at line 161 of file MultiAppTransfer.h.

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

◆ _to_var_name

AuxVariableName MultiAppConservativeTransfer::_to_var_name
protectedinherited

Definition at line 46 of file MultiAppConservativeTransfer.h.

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

◆ _to_var_names

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

Name of variables transferring to.

Definition at line 42 of file MultiAppConservativeTransfer.h.

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

◆ _type

const std::string& MooseBase::_type
protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

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

◆ _use_nearestpoint_pps

bool MultiAppConservativeTransfer::_use_nearestpoint_pps
privateinherited

Whether to use a nearest point UserObject to obtain the conservation factor.

Definition at line 68 of file MultiAppConservativeTransfer.h.

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

◆ _user_object_name

std::string MultiAppUserObjectTransfer::_user_object_name
protected

Definition at line 88 of file MultiAppUserObjectTransfer.h.

Referenced by execute().

◆ app_param

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

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

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

◆ kokkos_object_param

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

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

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

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

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

Definition at line 61 of file MooseBase.h.

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

◆ name_param

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

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

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

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

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings
inherited

Definition at line 67 of file MooseObject.h.

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:36:25 for https://mooseframework.inl.gov by doxygen 1.9.8