Project values from one domain to another. More...

#include <MultiAppProjectionTransfer.h>

Inheritance diagram for MultiAppProjectionTransfer:

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
	MultiAppProjectionTransfer (const InputParameters &parameters)

virtual void	initialSetup () override
	Method called at the beginning of the simulation for checking integrity or doing one-time setup.

virtual void	execute () override
	Execute the transfer.

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
void	toMultiApp ()

void	fromMultiApp ()

void	assembleL2 (libMesh::EquationSystems &es, const std::string &system_name)

void	projectSolution (unsigned int to_problem)

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
MooseEnum	_proj_type

bool	_compute_matrix
	True, if we need to recompute the projection matrix.

std::vector< libMesh::LinearImplicitSystem * >	_proj_sys

unsigned int	_proj_var_num
	Having one projection variable number seems weird, but there is always one variable in every system being used for projection, thus is always going to be 0 unless something changes in libMesh or we change the way we project variables.

bool	_fixed_meshes

bool	_qps_cached

std::map< processor_id_type, std::vector< libMesh::Point > >	_cached_qps

std::map< processor_id_type, std::map< std::pair< unsigned int, unsigned int >, unsigned int > >	_cached_index_map

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

Friends
void	assemble_l2 (libMesh::EquationSystems &es, const std::string &system_name)

Detailed Description

Project values from one domain to another.

Definition at line 23 of file MultiAppProjectionTransfer.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

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

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

◆ DIRECTION

enum Transfer::DIRECTION

inherited

Enumerator
TO_MULTIAPP
FROM_MULTIAPP
BETWEEN_MULTIAPP

Definition at line 68 of file Transfer.h.

  {
    TO_MULTIAPP,
    FROM_MULTIAPP,
    BETWEEN_MULTIAPP
  };

Constructor & Destructor Documentation

◆ MultiAppProjectionTransfer()

MultiAppProjectionTransfer::MultiAppProjectionTransfer ( const InputParameters & parameters )

Definition at line 69 of file MultiAppProjectionTransfer.C.

  : MultiAppConservativeTransfer(parameters),
    _proj_type(getParam<MooseEnum>("proj_type")),
    _compute_matrix(true),
    _fixed_meshes(getParam<bool>("fixed_meshes")),
    _qps_cached(false)
{
  if (_to_var_names.size() != 1)
    paramError("variable", " Support single to-variable only ");
 
  if (_from_var_names.size() != 1)
    paramError("source_variable", " Support single from-variable only ");
}

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.

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

Referenced by MultiAppNearestNodeTransfer::validParams(), 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.

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

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.

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

Referenced by MultiAppGeneralFieldUserObjectTransfer::validParams(), MultiAppPostprocessorToAuxScalarTransfer::validParams(), MultiAppPostprocessorTransfer::validParams(), MultiAppUserObjectTransfer::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.

{
  PostprocessorValue from_adjuster = 0;
  if (from_problem)
    from_adjuster = from_problem->getPostprocessorValueByName(from_postprocessor);
  else
    from_adjuster = 0;
 
  /* Everyone on the parent side should know this value; use it to scale the solution */
  if (_current_direction == FROM_MULTIAPP)
  {
    /* In this case, only one subapp has value, and other subapps' must be zero.
     *  We should see the maximum value.
     */
    PostprocessorValue from_adjuster_tmp = from_adjuster;
    comm().max(from_adjuster);
 
    /* We may have a negative value, and let us try it again  */
    if (MooseUtils::absoluteFuzzyLessEqual(from_adjuster, 0.))
    {
      comm().min(from_adjuster_tmp);
      from_adjuster = from_adjuster_tmp;
    }
  }
 
  // Compute to-postprocessor to have the adjuster
  to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
 
  // Now we should have the right adjuster based on the transferred solution
  const auto to_adjuster = to_problem.getPostprocessorValueByName(to_postprocessor);
 
  // decide if the adjustment should be performed
  if (!performAdjustment(from_adjuster, to_adjuster))
    return;
 
  auto & to_var = to_problem.getVariable(
      0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
  auto & to_sys = to_var.sys().system();
  auto var_num = to_sys.variable_number(_to_var_name);
  auto sys_num = to_sys.number();
  auto * pps =
      dynamic_cast<const BlockRestrictable *>(&(to_problem.getUserObjectBase(to_postprocessor)));
  auto & to_solution = to_var.sys().solution();
  auto & to_mesh = to_problem.mesh().getMesh();
  auto & moose_mesh = to_problem.mesh();
  bool is_nodal = to_sys.variable_type(var_num).family == LAGRANGE;
  if (is_nodal)
  {
    for (const auto & node : to_mesh.local_node_ptr_range())
    {
      // Skip this node if the variable has no dofs at it.
      if (node->n_dofs(sys_num, var_num) < 1)
        continue;
 
      bool scale_current_node = false;
      /* If we care about block IDs */
      if (pps)
      {
        auto & blockids = pps->blockIDs();
        auto & node_to_elem_map = moose_mesh.nodeToElemMap();
        auto neighbor_elements = node_to_elem_map.find(node->id());
        for (auto element : neighbor_elements->second)
        {
          auto & elem = to_mesh.elem_ref(element);
          if (blockids.find(elem.subdomain_id()) != blockids.end())
          {
            scale_current_node = true;
            break;
          }
        }
      }
      else
      {
        scale_current_node = true;
      }
      /* Need to scale this node */
      if (scale_current_node)
      {
        dof_id_type dof = node->dof_number(sys_num, var_num, 0);
        to_solution.set(dof, (from_adjuster / to_adjuster) * to_solution(dof));
      }
    }
  }
  else
  {
    for (auto & elem : as_range(to_mesh.local_elements_begin(), to_mesh.local_elements_end()))
    {
      // Skip this element if the variable has no dofs at it.
      if (elem->n_dofs(sys_num, var_num) < 1)
        continue;
 
      bool scale_current_element = false;
      if (pps)
      {
        auto & blockids = pps->blockIDs();
        if (blockids.find(elem->subdomain_id()) != blockids.end())
        {
          scale_current_element = true;
        }
      }
      else
      {
        scale_current_element = true;
      }
      if (scale_current_element)
      {
        unsigned int n_comp = elem->n_comp(sys_num, var_num);
 
        for (unsigned int offset = 0; offset < n_comp; offset++)
        {
          dof_id_type dof = elem->dof_number(sys_num, var_num, offset);
          to_solution.set(dof, (from_adjuster / to_adjuster) * to_solution(dof));
        }
      }
    }
  }
 
  to_solution.close();
  to_sys.update();
 
  // Compute again so that the post-processor has the value with the updated solution
  to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
}

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.

{
  PostprocessorValue from_adjuster = 0;
  if (from_problem && _current_direction == FROM_MULTIAPP)
    from_adjuster = from_problem->getPostprocessorValueByName(from_postprocessor);
  else
    from_adjuster = 0;
 
  /* Everyone on the parent application side should know this value; use it to scale the solution */
  if (_current_direction == FROM_MULTIAPP)
  {
    /* In this case, only one subapp has value, and other subapps' must be zero.
     *  We should see the maximum value.
     */
    PostprocessorValue from_adjuster_tmp = from_adjuster;
    comm().max(from_adjuster);
 
    /* We may have a negative value */
    if (MooseUtils::absoluteFuzzyLessEqual(from_adjuster, 0.))
    {
      comm().min(from_adjuster_tmp);
      from_adjuster = from_adjuster_tmp;
    }
  }
 
  PostprocessorValue to_adjuster = 0;
  // Compute to-postprocessor to have the adjuster
  if (_current_direction == TO_MULTIAPP)
  {
    to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
    to_adjuster = to_problem.getPostprocessorValueByName(to_postprocessor);
  }
 
  auto & to_var = to_problem.getVariable(
      0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
  auto & to_sys = to_var.sys().system();
  auto var_num = to_sys.variable_number(_to_var_name);
  auto sys_num = to_sys.number();
  auto & pps = static_cast<const NearestPointIntegralVariablePostprocessor &>(
      _current_direction == FROM_MULTIAPP ? (to_problem.getUserObjectBase(to_postprocessor))
                                          : (from_problem->getUserObjectBase(from_postprocessor)));
  auto & to_solution = to_var.sys().solution();
  auto & to_mesh = to_problem.mesh().getMesh();
  bool is_nodal = to_sys.variable_type(var_num).family == LAGRANGE;
  if (is_nodal)
  {
    for (const auto & node : to_mesh.local_node_ptr_range())
    {
      // Skip this node if the variable has no dofs at it.
      if (node->n_dofs(sys_num, var_num) < 1)
        continue;
 
      Real scale = 1;
      if (_current_direction == FROM_MULTIAPP)
      {
        auto ii = pps.nearestPointIndex(*node);
        if (ii != i || !performAdjustment(from_adjuster, pps.userObjectValue(i)))
          continue;
 
        scale = from_adjuster / pps.userObjectValue(i);
      }
      else
      {
        if (!performAdjustment(pps.userObjectValue(i), to_adjuster))
          continue;
 
        scale = pps.userObjectValue(i) / to_adjuster;
      }
 
      /* Need to scale this node */
      dof_id_type dof = node->dof_number(sys_num, var_num, 0);
      to_solution.set(dof, scale * to_solution(dof));
    }
  }
  else
  {
    for (auto & elem : as_range(to_mesh.local_elements_begin(), to_mesh.local_elements_end()))
    {
      // Skip this element if the variable has no dofs at it.
      if (elem->n_dofs(sys_num, var_num) < 1)
        continue;
 
      Real scale = 1;
      if (_current_direction == FROM_MULTIAPP)
      {
        unsigned int ii = pps.nearestPointIndex(elem->vertex_average());
        if (ii != i || !performAdjustment(from_adjuster, pps.userObjectValue(i)))
          continue;
 
        scale = from_adjuster / pps.userObjectValue(i);
      }
      else
      {
        if (!performAdjustment(pps.userObjectValue(i), to_adjuster))
          continue;
 
        scale = pps.userObjectValue(i) / to_adjuster;
      }
 
      dof_id_type dof = elem->dof_number(sys_num, var_num, 0);
      to_solution.set(dof, scale * to_solution(dof));
    }
  }
 
  to_solution.close();
  to_sys.update();
 
  // Compute the to-postprocessor again so that it has the right value with the updated solution
  if (_current_direction == TO_MULTIAPP)
    to_problem.computeUserObjectByName(EXEC_TRANSFER, Moose::POST_AUX, to_postprocessor);
}

Referenced by MultiAppConservativeTransfer::postExecute().

◆ assembleL2()

void MultiAppProjectionTransfer::assembleL2	(	libMesh::EquationSystems &	es,
		const std::string &	system_name
	)

protected

Definition at line 125 of file MultiAppProjectionTransfer.C.

{
  // Get the system and mesh from the input arguments.
  LinearImplicitSystem & system = es.get_system<LinearImplicitSystem>(system_name);
  MeshBase & to_mesh = es.get_mesh();
 
  // Get the meshfunction evaluations and the map that was stashed in the es.
  std::vector<Real> & final_evals = *es.parameters.get<std::vector<Real> *>("final_evals");
  std::map<dof_id_type, unsigned int> & element_map =
      *es.parameters.get<std::map<dof_id_type, unsigned int> *>("element_map");
 
  // Setup system vectors and matrices.
  FEType fe_type = system.variable_type(0);
  std::unique_ptr<FEBase> fe(FEBase::build(to_mesh.mesh_dimension(), fe_type));
  QGauss qrule(to_mesh.mesh_dimension(), fe_type.default_quadrature_order());
  fe->attach_quadrature_rule(&qrule);
  const DofMap & dof_map = system.get_dof_map();
  DenseMatrix<Number> Ke;
  DenseVector<Number> Fe;
  std::vector<dof_id_type> dof_indices;
  const std::vector<Real> & JxW = fe->get_JxW();
  const std::vector<std::vector<Real>> & phi = fe->get_phi();
  auto & system_matrix = system.get_system_matrix();
 
  for (const auto & elem : to_mesh.active_local_element_ptr_range())
  {
    fe->reinit(elem);
 
    dof_map.dof_indices(elem, dof_indices);
    Ke.resize(dof_indices.size(), dof_indices.size());
    Fe.resize(dof_indices.size());
 
    for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
    {
      Real meshfun_eval = 0.;
      if (element_map.find(elem->id()) != element_map.end())
      {
        // We have evaluations for this element.
        meshfun_eval = final_evals[element_map[elem->id()] + qp];
      }
 
      // Now compute the element matrix and RHS contributions.
      for (unsigned int i = 0; i < phi.size(); i++)
      {
        // RHS
        Fe(i) += JxW[qp] * (meshfun_eval * phi[i][qp]);
 
        if (_compute_matrix)
          for (unsigned int j = 0; j < phi.size(); j++)
          {
            // The matrix contribution
            Ke(i, j) += JxW[qp] * (phi[i][qp] * phi[j][qp]);
          }
      }
      dof_map.constrain_element_matrix_and_vector(Ke, Fe, dof_indices);
 
      if (_compute_matrix)
        system_matrix.add_matrix(Ke, dof_indices);
      system.rhs->add_vector(Fe, dof_indices);
    }
  }
}

◆ callMooseError() [1/2]

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

staticinherited

External method for calling moose error with added object context.

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

Parameters

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

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

◆ callMooseError() [2/2]

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

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

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

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

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

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

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.

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

Referenced by MultiAppGeneralFieldFunctorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppUserObjectTransfer::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.

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

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_problem	The problem that should contain the variable
var_name	The name of the variable that should exist within the problem
param_name	(optional) The input file parameter name for throwing paramError, if not provided a mooseError is thrown.

Definition at line 613 of file MultiAppTransfer.C.

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

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

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

Definition at line 77 of file MooseBase.C.

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

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

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

◆ declareRecoverableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

Note - this data will NOT be restored on Restart!

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

Parameters

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

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 276 of file Restartable.h.

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

◆ 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_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 310 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 301 of file Restartable.h.

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

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 330 of file Restartable.h.

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

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;
 
  _restartable_name = object_name;
 
  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
 
  _restartable_name = old_name;
 
  return value;
}

◆ direction()

MooseEnum Transfer::direction ( )

inlineinherited

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

Definition at line 84 of file Transfer.h.

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_name name of the object to check the execute_on flags for

Definition at line 721 of file MultiAppTransfer.C.

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

Referenced by MultiAppGeneralFieldFunctorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppUserObjectTransfer::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 MultiAppProjectionTransfer::execute ( )

overridevirtual

Execute the transfer.

Implements Transfer.

Definition at line 189 of file MultiAppProjectionTransfer.C.

{
  TIME_SECTION(
      "MultiAppProjectionTransfer::execute()", 5, "Transferring variables through projection");
 
  // We are going to project the solutions by solving some linear systems.  In
  // order to assemble the systems, we need to evaluate the "from" domain
  // solutions at quadrature points in the "to" domain.  Some parallel
  // communication is necessary because each processor doesn't necessarily have
  // all the "from" information it needs to set its "to" values.  We don't want
  // to use a bunch of big all-to-all broadcasts, so we'll use bounding boxes to
  // figure out which processors have the information we need and only
  // communicate with those processors.
  //
  // Each processor will
  // 1. Check its local quadrature points in the "to" domains to see which
  //    "from" domains they might be in.
  // 2. Send quadrature points to the processors with "from" domains that might
  //    contain those points.
  // 3. Recieve quadrature points from other processors, evaluate its mesh
  //    functions at those points, and send the values back to the proper
  //    processor
  // 4. Recieve mesh function evaluations from all relevant processors and
  //    decide which one to use at every quadrature point (the lowest global app
  //    index always wins)
  // 5. And use the mesh function evaluations to assemble and solve an L2
  //    projection system on its local elements.
 
  // For every combination of global "from" problem and local "to" problem, find
  // which "from" bounding boxes overlap with which "to" elements.  Keep track
  // of which processors own bounding boxes that overlap with which elements.
  // Build vectors of quadrature points to send to other processors for mesh
  // function evaluations.
 
  // Get the bounding boxes for the "from" domains.
  std::vector<BoundingBox> bboxes = getFromBoundingBoxes();
 
  // Figure out how many "from" domains each processor owns.
  std::vector<unsigned int> froms_per_proc = getFromsPerProc();
 
  std::map<processor_id_type, std::vector<Point>> outgoing_qps;
  std::map<processor_id_type, std::map<std::pair<unsigned int, unsigned int>, unsigned int>>
      element_index_map;
  // element_index_map[i_to, element_id] = index
  // outgoing_qps[index] is the first quadrature point in element
 
  if (!_qps_cached)
  {
    for (unsigned int i_to = 0; i_to < _to_problems.size(); i_to++)
    {
      // Indexing into the coordinate transforms vector
      const auto to_global_num =
          _current_direction == FROM_MULTIAPP ? 0 : _to_local2global_map[i_to];
      MeshBase & to_mesh = _to_meshes[i_to]->getMesh();
 
      LinearImplicitSystem & system = *_proj_sys[i_to];
 
      FEType fe_type = system.variable_type(0);
      std::unique_ptr<FEBase> fe(FEBase::build(to_mesh.mesh_dimension(), fe_type));
      QGauss qrule(to_mesh.mesh_dimension(), fe_type.default_quadrature_order());
      fe->attach_quadrature_rule(&qrule);
      const std::vector<Point> & xyz = fe->get_xyz();
 
      unsigned int from0 = 0;
      for (processor_id_type i_proc = 0; i_proc < n_processors();
           from0 += froms_per_proc[i_proc], i_proc++)
      {
        for (const auto & elem :
             as_range(to_mesh.local_elements_begin(), to_mesh.local_elements_end()))
        {
          fe->reinit(elem);
 
          bool qp_hit = false;
          for (unsigned int i_from = 0; i_from < froms_per_proc[i_proc] && !qp_hit; i_from++)
          {
            for (unsigned int qp = 0; qp < qrule.n_points() && !qp_hit; qp++)
            {
              Point qpt = xyz[qp];
              if (bboxes[from0 + i_from].contains_point((*_to_transforms[to_global_num])(qpt)))
                qp_hit = true;
            }
          }
 
          if (qp_hit)
          {
            // The selected processor's bounding box contains at least one
            // quadrature point from this element.  Send all qps from this element
            // and remember where they are in the array using the map.
            std::pair<unsigned int, unsigned int> key(i_to, elem->id());
            element_index_map[i_proc][key] = outgoing_qps[i_proc].size();
            for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
            {
              Point qpt = xyz[qp];
              outgoing_qps[i_proc].push_back((*_to_transforms[to_global_num])(qpt));
            }
          }
        }
      }
    }
 
    if (_fixed_meshes)
      _cached_index_map = element_index_map;
  }
  else
  {
    element_index_map = _cached_index_map;
  }
 
  // Request quadrature point evaluations from other processors and handle
  // requests sent to this processor.
 
  // Get the local bounding boxes.
  std::vector<BoundingBox> local_bboxes(froms_per_proc[processor_id()]);
  {
    // Find the index to the first of this processor's local bounding boxes.
    unsigned int local_start = 0;
    for (processor_id_type i_proc = 0; i_proc < n_processors() && i_proc != processor_id();
         i_proc++)
      local_start += froms_per_proc[i_proc];
 
    // Extract the local bounding boxes.
    for (unsigned int i_from = 0; i_from < froms_per_proc[processor_id()]; i_from++)
      local_bboxes[i_from] = bboxes[local_start + i_from];
  }
 
  // Setup the local mesh functions.
  std::vector<MeshFunction> local_meshfuns;
  for (unsigned int i_from = 0; i_from < _from_problems.size(); i_from++)
  {
    FEProblemBase & from_problem = *_from_problems[i_from];
    MooseVariableFEBase & from_var = from_problem.getVariable(
        0, _from_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
    System & from_sys = from_var.sys().system();
    unsigned int from_var_num = from_sys.variable_number(from_var.name());
 
    local_meshfuns.emplace_back(
        from_problem.es(), *from_sys.current_local_solution, from_sys.get_dof_map(), from_var_num);
    local_meshfuns.back().init();
    local_meshfuns.back().enable_out_of_mesh_mode(OutOfMeshValue);
  }
 
  // Recieve quadrature points from other processors, evaluate mesh frunctions
  // at those points, and send the values back.
  std::map<processor_id_type, std::vector<std::pair<Real, unsigned int>>> outgoing_evals_ids;
 
  // If there is no cached data, we need to do communication
  // Quadrature points I will receive from remote processors
  std::map<processor_id_type, std::vector<Point>> incoming_qps;
  if (!_qps_cached)
  {
    auto qps_action_functor = [&incoming_qps](processor_id_type pid, const std::vector<Point> & qps)
    {
      // Quadrature points from processor 'pid'
      auto & incoming_qps_from_pid = incoming_qps[pid];
      // Store data for late use
      incoming_qps_from_pid.reserve(incoming_qps_from_pid.size() + qps.size());
      std::copy(qps.begin(), qps.end(), std::back_inserter(incoming_qps_from_pid));
    };
 
    Parallel::push_parallel_vector_data(comm(), outgoing_qps, qps_action_functor);
  }
 
  // Cache data
  if (!_qps_cached)
    _cached_qps = incoming_qps;
 
  for (auto & qps : _cached_qps)
  {
    const processor_id_type pid = qps.first;
 
    outgoing_evals_ids[pid].resize(qps.second.size(),
                                   std::make_pair(OutOfMeshValue, libMesh::invalid_uint));
 
    for (unsigned int qp = 0; qp < qps.second.size(); qp++)
    {
      Point qpt = qps.second[qp];
 
      // Loop until we've found the lowest-ranked app that actually contains
      // the quadrature point.
      for (unsigned int i_from = 0; i_from < _from_problems.size(); i_from++)
      {
        if (local_bboxes[i_from].contains_point(qpt))
        {
          outgoing_evals_ids[pid][qp].first = (local_meshfuns[i_from])(
              getPointInSourceAppFrame(qpt, i_from, "Projection transfer evaluation"));
          if (_current_direction == FROM_MULTIAPP)
            outgoing_evals_ids[pid][qp].second = getGlobalSourceAppIndex(i_from);
        }
      }
    }
  }
 
  // Gather all of the qp evaluations and pick out the best ones for each qp.
 
  // Values back from remote processors for my local quadrature points
  std::map<processor_id_type, std::vector<std::pair<Real, unsigned int>>> incoming_evals_ids;
 
  auto evals_action_functor =
      [&incoming_evals_ids](processor_id_type pid,
                            const std::vector<std::pair<Real, unsigned int>> & evals)
  {
    // evals for processor 'pid'
    auto & incoming_evals_ids_for_pid = incoming_evals_ids[pid];
    // Copy evals for late use
    incoming_evals_ids_for_pid.reserve(incoming_evals_ids_for_pid.size() + evals.size());
    std::copy(evals.begin(), evals.end(), std::back_inserter(incoming_evals_ids_for_pid));
  };
 
  Parallel::push_parallel_vector_data(comm(), outgoing_evals_ids, evals_action_functor);
 
  std::vector<std::vector<Real>> final_evals(_to_problems.size());
  std::vector<std::map<dof_id_type, unsigned int>> trimmed_element_maps(_to_problems.size());
 
  for (unsigned int i_to = 0; i_to < _to_problems.size(); i_to++)
  {
    MeshBase & to_mesh = _to_meshes[i_to]->getMesh();
    LinearImplicitSystem & system = *_proj_sys[i_to];
 
    FEType fe_type = system.variable_type(0);
    std::unique_ptr<FEBase> fe(FEBase::build(to_mesh.mesh_dimension(), fe_type));
    QGauss qrule(to_mesh.mesh_dimension(), fe_type.default_quadrature_order());
 
    for (const auto & elem : to_mesh.active_local_element_ptr_range())
    {
      qrule.init(*elem);
 
      bool element_is_evaled = false;
      std::vector<Real> evals(qrule.n_points(), 0.);
 
      for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
      {
        unsigned int lowest_app_rank = libMesh::invalid_uint;
        for (auto & values_ids : incoming_evals_ids)
        {
          // Current processor id
          const processor_id_type pid = values_ids.first;
 
          // Ignore the selected processor if the element wasn't found in it's
          // bounding box.
          std::map<std::pair<unsigned int, unsigned int>, unsigned int> & map =
              element_index_map[pid];
          std::pair<unsigned int, unsigned int> key(i_to, elem->id());
          if (map.find(key) == map.end())
            continue;
          unsigned int qp0 = map[key];
 
          // Ignore the selected processor if it's app has a higher rank than the
          // previously found lowest app rank.
          if (_current_direction == FROM_MULTIAPP)
            if (values_ids.second[qp0 + qp].second >= lowest_app_rank)
              continue;
 
          // Ignore the selected processor if the qp was actually outside the
          // processor's subapp's mesh.
          if (values_ids.second[qp0 + qp].first == OutOfMeshValue)
            continue;
 
          // This is the best meshfunction evaluation so far, save it.
          element_is_evaled = true;
          evals[qp] = values_ids.second[qp0 + qp].first;
        }
      }
 
      // If we found good evaluations for any of the qps in this element, save
      // those evaluations for later.
      if (element_is_evaled)
      {
        trimmed_element_maps[i_to][elem->id()] = final_evals[i_to].size();
        for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
          final_evals[i_to].push_back(evals[qp]);
      }
    }
  }
 
  // We now have just one or zero mesh function values at all of our local
  // quadrature points.  Stash those values (and a map linking them to element
  // ids) in the equation systems parameters and project the solution.
 
  for (unsigned int i_to = 0; i_to < _to_problems.size(); i_to++)
  {
    _to_es[i_to]->parameters.set<std::vector<Real> *>("final_evals") = &final_evals[i_to];
    _to_es[i_to]->parameters.set<std::map<dof_id_type, unsigned int> *>("element_map") =
        &trimmed_element_maps[i_to];
    projectSolution(i_to);
    _to_es[i_to]->parameters.set<std::vector<Real> *>("final_evals") = NULL;
    _to_es[i_to]->parameters.set<std::map<dof_id_type, unsigned int> *>("element_map") = NULL;
  }
 
  if (_fixed_meshes)
    _qps_cached = true;
 
  postExecute();
}

◆ extendBoundingBoxes()

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

protectedinherited

Extends bounding boxes to avoid missing points.

Definition at line 466 of file MultiAppTransfer.C.

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

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

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

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

Definition at line 91 of file Transfer.C.

{
  // Find the system this variable is from
  for (unsigned int i = 0; i < es.n_systems(); i++)
    if (es.get_system(i).has_variable(var_name))
      return &es.get_system(i);
 
  ::mooseError("Unable to find variable " + var_name + " in any system.");
 
  // Unreachable
  return &es.get_system(0);
}

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

◆ flagInvalidSolutionInternal()

template<bool warning>

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

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

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

◆ fromMultiApp()

void MultiAppProjectionTransfer::fromMultiApp ( )

protected

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

{
  // I would like to do all of this in initialSetup, but it will fail with
  // multiapps that reset.  A reset deletes and rebuilds the FEProblems so all
  // of the pointers will be broken.
 
  // Clear the vectors since we've probably built them up from a previous call
  _from_problems.clear();
  _to_problems.clear();
  _from_es.clear();
  _to_es.clear();
  _from_meshes.clear();
  _to_meshes.clear();
  _to_positions.clear();
  _from_positions.clear();
  _to_transforms.clear();
  _from_transforms.clear();
  // Clear this map since we build it from scratch every time we transfer
  // Otherwise, this will cause two issues: 1) increasing memory usage
  // for a simulation that requires many transfers, 2) producing wrong results
  // when we do collective communication on this vector.
  _to_local2global_map.clear();
  _from_local2global_map.clear();
 
  // Build the vectors for to problems, from problems, and subapps positions.
  if (_current_direction == FROM_MULTIAPP)
  {
    _to_problems.push_back(&_from_multi_app->problemBase());
    _to_positions.push_back(Point(0., 0., 0.));
    getFromMultiAppInfo();
  }
  else if (_current_direction == TO_MULTIAPP)
  {
    _from_problems.push_back(&_to_multi_app->problemBase());
    _from_positions.push_back(Point(0., 0., 0.));
    getToMultiAppInfo();
  }
  else if (_current_direction == BETWEEN_MULTIAPP)
  {
    mooseAssert(&_from_multi_app->problemBase().coordTransform() ==
                    &_to_multi_app->problemBase().coordTransform(),
                "I believe these should be the same. If not, then it will be difficult to define a "
                "canonical reference frame.");
    getToMultiAppInfo();
    getFromMultiAppInfo();
  }
 
  // Build the from and to equation systems and mesh vectors.
  for (unsigned int i = 0; i < _to_problems.size(); i++)
  {
    // TODO: Do I actually want es or displaced es?
    _to_es.push_back(&_to_problems[i]->es());
    if (_displaced_target_mesh && _to_problems[i]->getDisplacedProblem())
      _to_meshes.push_back(&_to_problems[i]->getDisplacedProblem()->mesh());
    else
      _to_meshes.push_back(&_to_problems[i]->mesh());
  }
 
  for (unsigned int i = 0; i < _from_problems.size(); i++)
  {
    _from_es.push_back(&_from_problems[i]->es());
    if (_displaced_source_mesh && _from_problems[i]->getDisplacedProblem())
      _from_meshes.push_back(&_from_problems[i]->getDisplacedProblem()->mesh());
    else
      _from_meshes.push_back(&_from_problems[i]->mesh());
  }
 
  MooseAppCoordTransform::MinimalData from_app_transform_construction_data{};
  if (_communicator.rank() == 0)
    from_app_transform_construction_data =
        _current_direction == TO_MULTIAPP
            ? _to_multi_app->problemBase().coordTransform().minimalDataDescription()
            : _from_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
  _communicator.broadcast(from_app_transform_construction_data);
  _from_moose_app_transform =
      std::make_unique<MooseAppCoordTransform>(from_app_transform_construction_data);
 
  MooseAppCoordTransform::MinimalData to_app_transform_construction_data{};
  if (_communicator.rank() == 0)
    to_app_transform_construction_data =
        _current_direction == FROM_MULTIAPP
            ? _from_multi_app->problemBase().coordTransform().minimalDataDescription()
            : _to_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
  _communicator.broadcast(to_app_transform_construction_data);
  _to_moose_app_transform =
      std::make_unique<MooseAppCoordTransform>(to_app_transform_construction_data);
 
  /*
   * skip_coordinate_collapsing: whether to set the transform to skip coordinate collapsing
   *                             (from XYZ to RZ for example)
   * transforms: vector of transforms to add the new transforms to
   * moose_app_transform: base for the new transform
   * is_parent_app_transform: whether working on the transform for the parent app (this app, the
   *                          one creating the transfer) or for child apps
   * multiapp: pointer to the multiapp to obtain the position of the child apps
   */
  auto create_multiapp_transforms = [this](auto & transforms,
                                           const auto & moose_app_transform,
                                           const bool is_parent_app_transform,
                                           const MultiApp * const multiapp = nullptr)
  {
    mooseAssert(is_parent_app_transform || multiapp,
                "Coordinate transform must be created either for child app or parent app");
    if (is_parent_app_transform)
    {
      transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
      transforms.back()->skipCoordinateCollapsing(_skip_coordinate_collapsing);
      // zero translation
    }
    else
    {
      mooseAssert(transforms.size() == 0, "transforms should not be initialized at this point");
      for (const auto i : make_range(multiapp->numGlobalApps()))
      {
        transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
        auto & transform = transforms[i];
        transform->skipCoordinateCollapsing(_skip_coordinate_collapsing);
        if (multiapp->usingPositions())
          transform->setTranslationVector(multiapp->position(i));
      }
    }
  };
 
  if (_current_direction == TO_MULTIAPP)
  {
    create_multiapp_transforms(
        _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
    create_multiapp_transforms(_from_transforms, *_from_moose_app_transform, true);
  }
  if (_current_direction == FROM_MULTIAPP)
  {
    create_multiapp_transforms(_to_transforms, *_to_moose_app_transform, true);
    create_multiapp_transforms(
        _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
  }
  if (_current_direction == BETWEEN_MULTIAPP)
  {
    create_multiapp_transforms(
        _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
    create_multiapp_transforms(
        _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
  }
 
  auto check_transform_compatibility = [this](const MultiAppCoordTransform & transform)
  {
    if (transform.hasNonTranslationTransformation() && !usesMooseAppCoordTransform())
      mooseWarning("Transfer '",
                   name(),
                   "' of type '",
                   type(),
                   "' has non-translation transformations but it does not implement coordinate "
                   "transformations using the 'MooseAppCoordTransform' class. Your data transfers "
                   "will not be performed in the expected transformed frame");
  };
 
  // set the destination coordinate systems for each transform for the purposes of determining
  // coordinate collapsing. For example if TO is XYZ and FROM is RZ, then TO will have its XYZ
  // coordinates collapsed into RZ and FROM will have a no-op for coordinate collapsing
 
  for (const auto i : index_range(_from_transforms))
  {
    auto & from_transform = _from_transforms[i];
    from_transform->setDestinationCoordTransform(*_to_moose_app_transform);
    if (i == 0)
      check_transform_compatibility(*from_transform);
  }
  for (const auto i : index_range(_to_transforms))
  {
    auto & to_transform = _to_transforms[i];
    to_transform->setDestinationCoordTransform(*_from_moose_app_transform);
    if (i == 0)
      check_transform_compatibility(*to_transform);
  }
}

Referenced by MultiAppUserObjectTransfer::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.

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

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  if (error)
    _parent.mooseError(*error);
 
  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");
 
  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);
 
  return found_path.path;
}

Referenced by DataFileInterface::getDataFileNameByName().

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

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

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.

{
  return _execute_enum;
}

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.

{
  std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
  for (unsigned int i = 0; i < _from_meshes.size(); i++)
  {
    // Get a bounding box around the mesh elements that are local to the current
    // processor.
    BoundingBox bbox = MeshTools::create_local_bounding_box(*_from_meshes[i]);
 
    // Translate the bounding box to the from domain's position. We may have rotations so we must
    // be careful in constructing the new min and max (first and second)
    const auto from_global_num = getGlobalSourceAppIndex(i);
    transformBoundingBox(bbox, *_from_transforms[from_global_num]);
 
    // Cast the bounding box into a pair of points (so it can be put through
    // MPI communication).
    bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
  }
 
  // Serialize the bounding box points.
  _communicator.allgather(bb_points);
 
  // Recast the points back into bounding boxes and return.
  std::vector<BoundingBox> bboxes(bb_points.size());
  for (unsigned int i = 0; i < bb_points.size(); i++)
    bboxes[i] = static_cast<BoundingBox>(bb_points[i]);
 
  // possibly extend bounding boxes
  extendBoundingBoxes(_bbox_factor, bboxes);
 
  return bboxes;
}

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

◆ getFromBoundingBoxes() [2/2]

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

protectedinherited

Definition at line 530 of file MultiAppTransfer.C.

{
  std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
  const Real min_r = std::numeric_limits<Real>::lowest();
  const Real max_r = std::numeric_limits<Real>::max();
 
  for (unsigned int i = 0; i < _from_meshes.size(); i++)
  {
 
    Point min(max_r, max_r, max_r);
    Point max(min_r, min_r, min_r);
    bool at_least_one = false;
 
    // TODO: Factor this into mesh_tools after adding new boundary bounding box routine.
    const ConstBndNodeRange & bnd_nodes = *_from_meshes[i]->getBoundaryNodeRange();
    for (const auto & bnode : bnd_nodes)
    {
      if (bnode->_bnd_id == boundary_id &&
          bnode->_node->processor_id() == _from_meshes[i]->processor_id())
      {
        at_least_one = true;
        const auto & node = *bnode->_node;
        for (const auto i : make_range(Moose::dim))
        {
          min(i) = std::min(min(i), node(i));
          max(i) = std::max(max(i), node(i));
        }
      }
    }
 
    BoundingBox bbox(min, max);
    if (!at_least_one)
      bbox.min() = max; // If we didn't hit any nodes, this will be _the_ minimum bbox
    else
    {
      // Translate the bounding box to the from domain's position. We may have rotations so we must
      // be careful in constructing the new min and max (first and second)
      const auto from_global_num = getGlobalSourceAppIndex(i);
      transformBoundingBox(bbox, *_from_transforms[from_global_num]);
    }
 
    // Cast the bounding box into a pair of points (so it can be put through
    // MPI communication).
    bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
  }
 
  // Serialize the bounding box points.
  _communicator.allgather(bb_points);
 
  // Recast the points back into bounding boxes and return.
  std::vector<BoundingBox> bboxes(bb_points.size());
  for (unsigned int i = 0; i < bb_points.size(); i++)
    bboxes[i] = static_cast<BoundingBox>(bb_points[i]);
 
  // possibly extend bounding boxes
  extendBoundingBoxes(_bbox_factor, bboxes);
 
  return bboxes;
}

◆ getFromMultiApp()

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

inlineinherited

Get the MultiApp to transfer data from.

Definition at line 65 of file MultiAppTransfer.h.

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

◆ getFromMultiAppInfo()

void MultiAppTransfer::getFromMultiAppInfo ( )

privateinherited

Definition at line 451 of file MultiAppTransfer.C.

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

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.

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

◆ getFromsPerProc()

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

protectedinherited

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

Note: same indexing as getFromBoundingBoxes

Definition at line 591 of file MultiAppTransfer.C.

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

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

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

◆ getGlobalTargetAppIndex()

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

protectedinherited

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

Definition at line 672 of file MultiAppTransfer.C.

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

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.

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

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

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

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 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.

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

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

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

◆ 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

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

Returns: the point in the source app frame

Definition at line 647 of file MultiAppTransfer.C.

{
  return mapBackWithoutCollapsing(
      *_from_transforms[getGlobalSourceAppIndex(local_i_from)], p, phase);
}

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppGeneralFieldKDTreeTransferBase::checkRestrictionsForSource(), MultiAppGeneralFieldShapeEvaluationTransfer::evaluateInterpValuesWithMeshFunctions(), MultiAppGeneralFieldUserObjectTransfer::evaluateInterpValuesWithUserObjects(), MultiAppGeneralFieldFunctorTransfer::evaluateValues(), 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

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

Returns: the point in the target app frame

Definition at line 656 of file MultiAppTransfer.C.

{
  return mapBackWithoutCollapsing(*_to_transforms[getGlobalTargetAppIndex(local_i_to)], p, phase);
}

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

Definition at line 420 of file MooseBase.h.

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

◆ getRestartableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 294 of file Restartable.h.

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

◆ getSharedPtr() [1/2]

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

inherited

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

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

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

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.

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

◆ getToMultiApp()

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

inlineinherited

Get the MultiApp to transfer data to.

Definition at line 77 of file MultiAppTransfer.h.

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

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(), MultiAppUserObjectTransfer::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::MultiAppUserObjectTransfer(), and MultiAppConservativeTransfer::postExecute().

◆ getToMultiAppInfo()

void MultiAppTransfer::getToMultiAppInfo ( )

privateinherited

Definition at line 442 of file MultiAppTransfer.C.

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

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.

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

◆ getToVarNames()

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

inlineoverrideprotectedvirtualinherited

Virtual function defining variables to transfer to.

Implements MultiAppFieldTransfer.

Definition at line 35 of file MultiAppConservativeTransfer.h.

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.

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

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

◆ 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 MultiAppProjectionTransfer::initialSetup ( )

overridevirtual

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

Reimplemented from MultiAppConservativeTransfer.

Definition at line 84 of file MultiAppProjectionTransfer.C.

{
  MultiAppConservativeTransfer::initialSetup();
 
  _proj_sys.resize(_to_problems.size(), NULL);
 
  for (unsigned int i_to = 0; i_to < _to_problems.size(); i_to++)
  {
    FEProblemBase & to_problem = *_to_problems[i_to];
    EquationSystems & to_es = to_problem.es();
 
    // Add the projection system.
    FEType fe_type = to_problem
                         .getVariable(0,
                                      _to_var_name,
                                      Moose::VarKindType::VAR_ANY,
                                      Moose::VarFieldType::VAR_FIELD_STANDARD)
                         .feType();
 
    LinearImplicitSystem & proj_sys = to_es.add_system<LinearImplicitSystem>("proj-sys-" + name());
 
    _proj_var_num = proj_sys.add_variable("var", fe_type);
    proj_sys.attach_assemble_function(assemble_l2);
    _proj_sys[i_to] = &proj_sys;
 
    // Prevent the projection system from being written to checkpoint
    // files.  In the event of a recover or restart, we'll read the checkpoint
    // before this initialSetup method is called.  As a result, we'll find
    // systems in the checkpoint (the projection systems) that we don't know
    // what to do with, and there will be a crash.  We could fix this by making
    // the systems in the constructor, except we don't know how many sub apps
    // there are at the time of construction.  So instead, we'll just nuke the
    // projection system and rebuild it from scratch every recover/restart.
    proj_sys.hide_output() = true;
 
    // Reinitialize EquationSystems since we added a system.
    to_es.reinit();
  }
}

◆ 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

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

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

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

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

Definition InputParameters.C:386

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

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

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.

  {
    return messagePrefix(_pars, hit_prefix);
  }

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

◆ messagePrefix() [2/2]

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

staticprivateinherited

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

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

Definition at line 140 of file MooseBase.C.

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

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 317 of file MooseBase.h.

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

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

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

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

Definition at line 327 of file MooseBase.h.

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 277 of file MooseBase.h.

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

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

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

◆ paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 457 of file MooseBase.h.

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

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 471 of file MooseBase.h.

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

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

◆ paramWarning() [1/2]

template<typename... Args>

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

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

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

◆ performAdjustment()

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

protectedinherited

Definition at line 526 of file MultiAppConservativeTransfer.C.

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

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.

{
  if (_preserve_transfer)
  {
    TIME_SECTION("MultiAppConservativeTransfer::execute()",
                 5,
                 "Post transfer to preserve postprocessor values");
 
    if (_current_direction == TO_MULTIAPP)
    {
      FEProblemBase & from_problem = getToMultiApp()->problemBase();
      if (_use_nearestpoint_pps)
        from_problem.computeUserObjectByName(
            EXEC_TRANSFER, Moose::POST_AUX, _from_postprocessors_to_be_preserved[0]);
 
      for (unsigned int i = 0; i < getToMultiApp()->numGlobalApps(); i++)
        if (getToMultiApp()->hasLocalApp(i))
        {
          if (_use_nearestpoint_pps)
            adjustTransferredSolutionNearestPoint(i,
                                                  &from_problem,
                                                  _from_postprocessors_to_be_preserved[0],
                                                  getToMultiApp()->appProblemBase(i),
                                                  _to_postprocessors_to_be_preserved[0]);
          else
            adjustTransferredSolution(&from_problem,
                                      _from_postprocessors_to_be_preserved[i],
                                      getToMultiApp()->appProblemBase(i),
                                      _to_postprocessors_to_be_preserved[0]);
        }
    }
 
    else if (_current_direction == FROM_MULTIAPP)
    {
      FEProblemBase & to_problem = getFromMultiApp()->problemBase();
      if (_use_nearestpoint_pps)
        to_problem.computeUserObjectByName(
            EXEC_TRANSFER, Moose::POST_AUX, _to_postprocessors_to_be_preserved[0]);
 
      for (unsigned int i = 0; i < getFromMultiApp()->numGlobalApps(); i++)
      {
        if (_use_nearestpoint_pps)
          adjustTransferredSolutionNearestPoint(
              i,
              getFromMultiApp()->hasLocalApp(i) ? &getFromMultiApp()->appProblemBase(i) : nullptr,
              _from_postprocessors_to_be_preserved[0],
              to_problem,
              _to_postprocessors_to_be_preserved[0]);
        else
          adjustTransferredSolution(
              getFromMultiApp()->hasLocalApp(i) ? &getFromMultiApp()->appProblemBase(i) : nullptr,
              _from_postprocessors_to_be_preserved[0],
              to_problem,
              _to_postprocessors_to_be_preserved[i]);
      }
 
      // Compute the to-postprocessor again so that it has the right value with the updated solution
      if (_use_nearestpoint_pps)
        to_problem.computeUserObjectByName(
            EXEC_TRANSFER, Moose::POST_AUX, _to_postprocessors_to_be_preserved[0]);
    }
  }
}

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

◆ projectSolution()

void MultiAppProjectionTransfer::projectSolution ( unsigned int to_problem )

protected

Definition at line 494 of file MultiAppProjectionTransfer.C.

{
  FEProblemBase & to_problem = *_to_problems[i_to];
  EquationSystems & proj_es = to_problem.es();
  LinearImplicitSystem & ls = *_proj_sys[i_to];
  // activate the current transfer
  proj_es.parameters.set<MultiAppProjectionTransfer *>("transfer") = this;
 
  // TODO: specify solver params in an input file
  // solver tolerance
  Real tol = proj_es.parameters.get<Real>("linear solver tolerance");
  proj_es.parameters.set<Real>("linear solver tolerance") = 1e-10; // set our tolerance
  // solve it
  ls.solve();
  proj_es.parameters.set<Real>("linear solver tolerance") = tol; // restore the original tolerance
 
  // copy projected solution into target es
  MeshBase & to_mesh = proj_es.get_mesh();
 
  MooseVariableFEBase & to_var = to_problem.getVariable(
      0, _to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
  System & to_sys = to_var.sys().system();
  NumericVector<Number> * to_solution = to_sys.solution.get();
 
  for (const auto & node : to_mesh.local_node_ptr_range())
  {
    for (unsigned int comp = 0; comp < node->n_comp(to_sys.number(), to_var.number()); comp++)
    {
      const dof_id_type proj_index = node->dof_number(ls.number(), _proj_var_num, comp);
      const dof_id_type to_index = node->dof_number(to_sys.number(), to_var.number(), comp);
      to_solution->set(to_index, (*ls.solution)(proj_index));
    }
  }
  for (const auto & elem : to_mesh.active_local_element_ptr_range())
    for (unsigned int comp = 0; comp < elem->n_comp(to_sys.number(), to_var.number()); comp++)
    {
      const dof_id_type proj_index = elem->dof_number(ls.number(), _proj_var_num, comp);
      const dof_id_type to_index = elem->dof_number(to_sys.number(), to_var.number(), comp);
      to_solution->set(to_index, (*ls.solution)(proj_index));
    }
 
  to_solution->close();
  to_sys.update();
}

Referenced by execute().

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

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

Parameters

name	The name of the parameter

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

Definition at line 413 of file MooseBase.h.

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

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

◆ registerInvalidSolutionInternal()

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

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

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

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

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

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.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

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_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns: The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

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

◆ registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

Returns: The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

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

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

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

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.

  {
    _current_direction = direction;
    _direction = direction;
  }

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.

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

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

◆ toMultiApp()

void MultiAppProjectionTransfer::toMultiApp ( )

protected

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

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

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.

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

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

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

Definition at line 57 of file MooseBase.C.

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

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

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

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

Definition at line 69 of file MooseBase.C.

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

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

◆ uniqueParameterName()

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

inherited

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

Definition at line 63 of file MooseBase.C.

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

◆ usesMooseAppCoordTransform()

bool MultiAppProjectionTransfer::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 61 of file MultiAppProjectionTransfer.h.

61{ return true; }

◆ validParams()

InputParameters MultiAppProjectionTransfer::validParams ( )

static

Definition at line 46 of file MultiAppProjectionTransfer.C.

{
  InputParameters params = MultiAppConservativeTransfer::validParams();
  params.addClassDescription(
      "Perform a projection between a master and sub-application mesh of a field variable.");
 
  MooseEnum proj_type("l2", "l2");
  params.addParam<MooseEnum>("proj_type", proj_type, "The type of the projection.");
 
  params.addParam<bool>("fixed_meshes",
                        false,
                        "Set to true when the meshes are not changing (ie, "
                        "no movement or adaptivity).  This will cache some "
                        "information to speed up the transfer.");
 
  // Need one layer of ghosting
  params.addRelationshipManager("ElementSideNeighborLayers",
                                Moose::RelationshipManagerType::GEOMETRIC |
                                    Moose::RelationshipManagerType::ALGEBRAIC);
  MultiAppTransfer::addBBoxFactorParam(params);
  return params;
}

◆ variableIntegrityCheck()

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

inherited

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

Definition at line 197 of file MultiAppTransfer.C.

{
  bool variable_found = false;
  bool has_an_app = false;
 
  // Check the from_multi_app for the variable
  if (is_from_multiapp && _from_multi_app)
    for (unsigned int i = 0; i < _from_multi_app->numGlobalApps(); i++)
      if (_from_multi_app->hasLocalApp(i))
      {
        has_an_app = true;
        if (_from_multi_app->appProblemBase(i).hasVariable(var_name))
          variable_found = true;
      }
 
  // Check the to_multi_app for the variable
  if (!is_from_multiapp && _to_multi_app)
    for (unsigned int i = 0; i < _to_multi_app->numGlobalApps(); i++)
      if (_to_multi_app->hasLocalApp(i))
      {
        has_an_app = true;
        if (_to_multi_app->appProblemBase(i).hasVariable(var_name))
          variable_found = true;
      }
 
  if (!variable_found && has_an_app)
    mooseError("Cannot find variable ", var_name, " for ", name(), " Transfer");
}

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

Friends And Related Symbol Documentation

◆ assemble_l2

void assemble_l2	(	libMesh::EquationSystems &	es,
		const std::string &	system_name
	)

friend

Definition at line 36 of file MultiAppProjectionTransfer.C.

{
  MultiAppProjectionTransfer * transfer =
      es.parameters.get<MultiAppProjectionTransfer *>("transfer");
  transfer->assembleL2(es, system_name);
}

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

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

◆ _cached_index_map

std::map<processor_id_type, std::map<std::pair<unsigned int, unsigned int>, unsigned int> > MultiAppProjectionTransfer::_cached_index_map

protected

Definition at line 58 of file MultiAppProjectionTransfer.h.

Referenced by execute().

◆ _cached_qps

std::map<processor_id_type, std::vector<libMesh::Point> > MultiAppProjectionTransfer::_cached_qps

protected

Definition at line 56 of file MultiAppProjectionTransfer.h.

Referenced by execute().

◆ _compute_matrix

bool MultiAppProjectionTransfer::_compute_matrix

protected

True, if we need to recompute the projection matrix.

Definition at line 45 of file MultiAppProjectionTransfer.h.

Referenced by assembleL2().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _current_direction

MooseEnum Transfer::_current_direction

protectedinherited

Definition at line 106 of file Transfer.h.

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

◆ _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(), MultiAppUserObjectTransfer::execute(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), MultiAppUserObjectTransfer::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.

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

◆ _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(), MultiAppUserObjectTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), MultiAppGeneralFieldKDTreeTransferBase::getNumDivisions(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::locatePointReceivers(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), and MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer().

◆ _fixed_meshes

bool MultiAppProjectionTransfer::_fixed_meshes

protected

Definition at line 54 of file MultiAppProjectionTransfer.h.

Referenced by execute().

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

◆ _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(), MultiAppUserObjectTransfer::execute(), MultiAppUserObjectTransfer::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 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(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::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 MultiAppUserObjectTransfer::execute(), MultiAppUserObjectTransfer::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.

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

◆ _proj_sys

std::vector<libMesh::LinearImplicitSystem *> MultiAppProjectionTransfer::_proj_sys

protected

Definition at line 46 of file MultiAppProjectionTransfer.h.

Referenced by execute(), initialSetup(), and projectSolution().

◆ _proj_type

MooseEnum MultiAppProjectionTransfer::_proj_type

protected

Definition at line 42 of file MultiAppProjectionTransfer.h.

◆ _proj_var_num

unsigned int MultiAppProjectionTransfer::_proj_var_num

protected

Having one projection variable number seems weird, but there is always one variable in every system being used for projection, thus is always going to be 0 unless something changes in libMesh or we change the way we project variables.

Definition at line 49 of file MultiAppProjectionTransfer.h.

Referenced by initialSetup(), and projectSolution().

◆ _qps_cached

bool MultiAppProjectionTransfer::_qps_cached

protected

Definition at line 55 of file MultiAppProjectionTransfer.h.

Referenced by execute().

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

◆ _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(), execute(), MultiAppUserObjectTransfer::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(), MultiAppUserObjectTransfer::execute(), initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), and 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(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::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().

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

include/transfers/MultiAppProjectionTransfer.h
src/transfers/MultiAppProjectionTransfer.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Member Enumeration Documentation

◆ DIRECTION

Constructor & Destructor Documentation

◆ MultiAppProjectionTransfer()

Member Function Documentation

◆ addBBoxFactorParam()

◆ addSkipCoordCollapsingParam()

◆ addUserObjectExecutionCheckParam()

◆ adjustTransferredSolution()

◆ adjustTransferredSolutionNearestPoint()

◆ assembleL2()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkMultiAppExecuteOn()

◆ checkParentAppUserObjectExecuteOn()

◆ checkSiblingsTransferSupported()

◆ checkVariable()

◆ connectControllableParams()

◆ currentDirection()

◆ customSetup()

◆ declareManagedRestartableDataWithContext()

◆ declareRecoverableData()

◆ declareRestartableData()

◆ declareRestartableDataHelper()

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ direction()

◆ directions()

◆ enabled()

◆ errorIfObjectExecutesOnTransferInSourceApp()

◆ errorPrefix()

◆ execute()

◆ extendBoundingBoxes()

◆ find_sys()

◆ flagInvalidSolutionInternal()

◆ fromMultiApp()

◆ getAppInfo()

◆ getBase()

◆ getCheckedPointerParam()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getEquationSystem()

◆ getExecuteOnEnum()

◆ getFromBoundingBoxes() [1/2]

◆ getFromBoundingBoxes() [2/2]

◆ getFromMultiApp()

◆ getFromMultiAppInfo()

◆ getFromName()

◆ getFromsPerProc()

◆ getFromVarNames()

◆ getGlobalSourceAppIndex()

◆ getGlobalTargetAppIndex()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getLocalSourceAppIndex()

◆ getMooseApp()

◆ getMultiApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getPointInSourceAppFrame()

◆ getPointInTargetAppFrame()

◆ getRenamedParam()

◆ getRestartableData()