A MultiApp represents one or more MOOSE applications that are running simultaneously. More...

#include <MultiApp.h>

Inheritance diagram for MultiApp:

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

Public Member Functions
	MultiApp (const InputParameters &parameters)

virtual void	preExecute ()

virtual void	finalize ()
	Method called towards the end of the simulation to execute on final.

virtual void	postExecute ()
	Method called at the end of the simulation (after finalize).

void	setupPositions ()
	Called just after construction to allow derived classes to set _positions and create sub-apps accordingly.

virtual void	createLocalApp (const unsigned int i)
	Create the i-th local app.

virtual void	initialSetup () override
	Method to be called in main-app initial setup for create sub-apps if using positions is false.

virtual void	preTransfer (Real dt, Real target_time)
	Gets called just before transfers are done to the MultiApp (Which is just before the MultiApp is solved).

virtual bool	solveStep (Real dt, Real target_time, bool auto_advance=true)=0
	Re-solve all of the Apps.

virtual void	incrementTStep (Real)
	Advances the multi-apps time step which is important for dt selection.

virtual void	finishStep (bool=false)
	Calls multi-apps executioners' endStep and postStep methods which creates output and advances time (not the time step; see incrementTStep()) among other things.

virtual void	backup ()
	Save off the state of every Sub App.

virtual void	restore (bool force=true)
	Restore the state of every Sub App.

bool	needsRestoration ()
	Whether or not this MultiApp should be restored at the beginning of each Picard iteration.

virtual Executioner *	getExecutioner (unsigned int app)

virtual libMesh::BoundingBox	getBoundingBox (unsigned int app, bool displaced_mesh, const MultiAppCoordTransform *coord_transform=nullptr)
	Get the BoundingBox for the mesh associated with app The bounding box will be shifted to be in the correct position within the master domain.

FEProblemBase &	problemBase ()
	Get the FEProblemBase this MultiApp is part of.

FEProblemBase &	appProblemBase (unsigned int app)
	Get the FEProblemBase for the global app desired.

FEProblem &	appProblem (unsigned int app)
	Get the FEProblem for the global app is part of.

const UserObject &	appUserObjectBase (unsigned int app, const std::string &name)
	Get a UserObject base for a specific global app.

Real	appPostprocessorValue (unsigned int app, const std::string &name)
	Get a Postprocessor value for a specified global app.

virtual libMesh::NumericVector< libMesh::Number > &	appTransferVector (unsigned int app, std::string var_name)
	Get the vector to transfer to for this MultiApp.

unsigned int	numGlobalApps () const

unsigned int	numLocalApps ()

unsigned int	firstLocalApp ()

bool	isFirstLocalRank () const

bool	hasApp ()
	Whether or not this MultiApp has an app on this processor.

bool	hasLocalApp (unsigned int global_app) const
	Whether or not the given global app number is on this processor.

MooseApp *	localApp (unsigned int local_app)
	Get the local MooseApp object.

const Point &	position (unsigned int app) const
	The physical position of a global App number.

virtual void	resetApp (unsigned int global_app, Real time=0.0)
	"Reset" the App corresponding to the global App number passed in.

virtual void	moveApp (unsigned int global_app, Point p)
	Move the global_app to Point p.

virtual void	parentOutputPositionChanged ()
	For apps outputting in position we need to change their output positions if their parent app moves.

MPI_Comm &	comm ()
	Get the MPI communicator this MultiApp is operating on.

bool	isRootProcessor ()
	Whether or not this processor is the "root" processor for the sub communicator.

bool	usingPositions () const
	Whether or not this MultiApp is using positions or its own way for constructing sub-apps.

bool	runningInPosition () const
	Whether or not this MultiApp is being run in position, eg with the coordinate transform already applied.

void	addAssociatedTransfer (MultiAppTransfer &transfer)
	Add a transfer that is associated with this multiapp.

void	setAppOutputFileBase ()
	Sets all the app's output file bases.

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.

Static Public Member Functions
static InputParameters	validParams ()

static void	transformBoundingBox (libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)
	Transform a bounding box according to the transformations in the provided coordinate transformation object.

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

Public Attributes
	usingCombinedWarningSolutionWarnings

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

Static Public Attributes
static const std::string	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
virtual std::vector< std::string >	cliArgs () const
	function that provides cli_args to subapps

virtual void	fillPositions ()
	must fill in _positions with the positions of the sub-aps

void	readCommandLineArguments ()
	Fill command line arguments for sub apps.

void	createApp (unsigned int i, Real start_time)
	Helper function for creating an App instance.

virtual bool	propagateRecoverToSubApps () const
	Whether or not to propagate the parent's recover state (the –recover and –test-checkpoint-half-transient flags) to sub-applications.

void	buildComm ()
	Create an MPI communicator suitable for each app.

unsigned int	globalAppToLocal (unsigned int global_app)
	Map a global App number to the local number.

virtual void	preRunInputFile ()
	call back executed right before app->runInputFile()

virtual std::vector< std::string >	getCommandLineArgs (const unsigned int local_app)

void	init (unsigned int num_apps, bool batch_mode=false)
	Build communicators and reserve backups.

void	init (unsigned int num_apps, const LocalRankConfig &config)
	Same as other init method, except defining a custom rank configuration.

void	createApps ()
	Create the provided number of apps.

void	keepSolutionDuringRestore (bool keep_solution_during_restore)
	Preserve the solution from the previous simulation, and it is used as an initial guess for the next run.

void	setAppOutputFileBase (unsigned int index)
	Set the output file base of the application which corresponds to the index passed to the function.

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

Static Protected Member Functions
static std::string	getMultiAppName (const std::string &base_name, dof_id_type index, dof_id_type total)
	Helper for constructing the name of the multiapp.

Protected Attributes
FEProblemBase &	_fe_problem
	The FEProblemBase this MultiApp is part of.

std::string	_app_type
	The type of application to build.

std::vector< Point >	_positions
	The positions of all of the apps, using input constant vectors (to be deprecated)

std::vector< const Positions * >	_positions_objs
	The positions of all of the apps, using the Positions system.

std::vector< unsigned int >	_positions_index_offsets
	The offsets, in case multiple Positions objects are specified.

const bool	_use_positions
	Toggle use of "positions".

std::vector< FileName >	_input_files
	The input file for each app's simulation.

const bool &	_wait_for_first_app_init
	Whether to create the first app on rank 0 while all other MPI ranks are idle.

std::vector< unsigned int >	_npositions_inputfile
	Number of positions for each input file.

std::string	_output_base
	The output file basename for each multiapp.

unsigned int	_total_num_apps
	The total number of apps to simulate.

unsigned int	_my_num_apps
	The number of apps this object is involved in simulating.

unsigned int	_first_local_app
	The number of the first app on this processor.

const MPI_Comm &	_orig_comm
	The original comm handle.

libMesh::Parallel::Communicator	_my_communicator
	The communicator object that holds the MPI_Comm that we're going to use.

MPI_Comm &	_my_comm
	The MPI communicator this object is going to use.

int	_orig_num_procs
	The number of processors in the original comm.

int	_orig_rank
	The mpi "rank" of this processor in the original communicator.

std::string	_node_name
	Node Name.

int	_my_rank
	The mpi "rank" of this processor in the sub communicator.

std::vector< std::shared_ptr< MooseApp > >	_apps
	Pointers to each of the Apps.

std::vector< bool >	_has_bounding_box
	Flag if this multi-app computed its bounding box (valid only for non-displaced meshes)

std::vector< libMesh::BoundingBox >	_bounding_box
	This multi-app's bounding box.

Real	_inflation
	Relative bounding box inflation.

Point	_bounding_box_padding
	Additional padding added to the bounding box, useful for 1D meshes.

processor_id_type	_max_procs_per_app
	Maximum number of processors to give to each app.

processor_id_type	_min_procs_per_app
	Minimum number of processors to give to each app.

bool	_output_in_position
	Whether or not to move the output of the MultiApp into position.

const Real	_global_time_offset
	The offset time so the MultiApp local time relative to the global time.

std::vector< Real >	_reset_times
	The times at which to reset apps.

std::vector< unsigned int >	_reset_apps
	The apps to be reset.

std::vector< bool >	_reset_happened
	Whether or not apps have been reset at each time.

Real	_move_time
	The time at which to move apps.

std::vector< unsigned int >	_move_apps
	The apps to be moved.

std::vector< Point >	_move_positions
	The new positions for the apps to be moved.

bool	_move_happened
	Whether or not the move has happened.

bool	_has_an_app
	Whether or not this processor as an App at all

const std::vector< CLIArgString > &	_cli_args
	CommandLine arguments (controllable!)

std::vector< std::string >	_cli_args_from_file
	CommandLine arguments from files.

bool	_keep_solution_during_restore
	Flag indicates if or not restart from the latest solution.

bool	_keep_aux_solution_during_restore
	Flag indicates if or not restart the auxiliary system from the latest auxiliary solution.

const bool	_no_restore
	Whether or not to skip restoring completely.

std::vector< std::vector< std::unique_ptr< libMesh::NumericVector< Real > > > >	_end_solutions
	The solution from the end of the previous solve, this is cloned from the Nonlinear solution during restore Outer indexing by child application, inner indexing by solver system.

std::vector< std::unique_ptr< NumericVector< Real > > >	_end_aux_solutions
	The auxiliary solution from the end of the previous solve, this is cloned from the auxiliary solution during restore.

LocalRankConfig	_rank_config
	The app configuration resulting from calling init.

std::vector< MultiAppTransfer * >	_associated_transfers
	Transfers associated with this multiapp.

const bool	_run_in_position
	Whether to run the child apps with their meshes transformed with the coordinate transforms.

SubAppBackups &	_sub_app_backups
	The cached subapp backups (passed from the parent app)

const PerfID	_solve_step_timer
	Timers.

const PerfID	_init_timer

const PerfID	_backup_timer

const PerfID	_restore_timer

const PerfID	_reset_timer

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.

Private Member Functions
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data.

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data.

template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data.

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

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

Private Attributes
std::optional< std::string >	_cli_args_param
	The parameter that was used to set the command line args, if any.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

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

const RestartableDataMapName	_metaname
	Restartable metadata name.

std::string	_restartable_name
	The name of the object.

Detailed Description

A MultiApp represents one or more MOOSE applications that are running simultaneously.

These other MOOSE apps generally represent some "sub-solve" or "embedded-solves" of the overall nonlinear solve. If your system support dynamic libraries unregistered Multiapps can be loaded on the fly by setting the exporting the appropriate library path using "MOOSE_LIBRARY_PATH" or by specifying a single input file library path in Multiapps InputParameters object.

Definition at line 112 of file MultiApp.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

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

Definition at line 27 of file DataFileInterface.h.

Constructor & Destructor Documentation

◆ MultiApp()

MultiApp::MultiApp ( const InputParameters & parameters )

Definition at line 277 of file MultiApp.C.

  : MooseObject(parameters),
    SetupInterface(this),
    Restartable(this, "MultiApps"),
    PerfGraphInterface(this, std::string("MultiApp::") + _name),
    _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
    _app_type(isParamValid("app_type") ? std::string(getParam<MooseEnum>("app_type"))
                                       : _fe_problem.getMooseApp().type()),
    _use_positions(getParam<bool>("use_positions")),
    _input_files(getParam<std::vector<FileName>>("input_files")),
    _wait_for_first_app_init(getParam<bool>("wait_for_first_app_init")),
    _total_num_apps(0),
    _my_num_apps(0),
    _first_local_app(0),
    _orig_comm(_communicator.get()),
    _my_communicator(),
    _my_comm(_my_communicator.get()),
    _my_rank(0),
    _inflation(getParam<Real>("bounding_box_inflation")),
    _bounding_box_padding(getParam<Point>("bounding_box_padding")),
    _max_procs_per_app(getParam<processor_id_type>("max_procs_per_app")),
    _min_procs_per_app(getParam<processor_id_type>("min_procs_per_app")),
    _output_in_position(getParam<bool>("output_in_position")),
    _global_time_offset(getParam<Real>("global_time_offset")),
    _reset_times(getParam<std::vector<Real>>("reset_time")),
    _reset_apps(getParam<std::vector<unsigned int>>("reset_apps")),
    _reset_happened(false),
    _move_time(getParam<Real>("move_time")),
    _move_apps(getParam<std::vector<unsigned int>>("move_apps")),
    _move_positions(getParam<std::vector<Point>>("move_positions")),
    _move_happened(false),
    _has_an_app(true),
    _cli_args(getParam<std::vector<CLIArgString>>("cli_args")),
    _keep_solution_during_restore(getParam<bool>("keep_solution_during_restore")),
    _keep_aux_solution_during_restore(getParam<bool>("keep_aux_solution_during_restore")),
    _no_restore(getParam<bool>("no_restore")),
    _run_in_position(getParam<bool>("run_in_position")),
    _sub_app_backups(declareRestartableDataWithContext<SubAppBackups>("sub_app_backups", this)),
    _solve_step_timer(registerTimedSection("solveStep", 3, "Executing MultiApps", false)),
    _init_timer(registerTimedSection("init", 3, "Initializing MultiApp")),
    _backup_timer(registerTimedSection("backup", 3, "Backing Up MultiApp")),
    _restore_timer(registerTimedSection("restore", 3, "Restoring MultiApp")),
    _reset_timer(registerTimedSection("resetApp", 3, "Resetting MultiApp"))
{
  if (parameters.isParamSetByUser("cli_args") && parameters.isParamValid("cli_args") &&
      parameters.isParamValid("cli_args_files"))
    paramError("cli_args",
               "'cli_args' and 'cli_args_files' cannot be specified simultaneously in MultiApp ");
 
  if (!_use_positions && (isParamValid("positions") || isParamValid("positions_file") ||
                          isParamValid("positions_objects")))
    paramError("use_positions",
               "This MultiApps has been set to not use positions, "
               "but a 'positions' parameter has been set.");
 
  if ((_reset_apps.size() > 0 && _reset_times.size() == 0) ||
      (_reset_apps.size() == 0 && _reset_times.size() > 0))
    mooseError("reset_time and reset_apps may only be specified together");
 
  // Check that the reset times are sorted by the user
  auto sorted_times = _reset_times;
  std::sort(sorted_times.begin(), sorted_times.end());
  if (_reset_times.size() && _reset_times != sorted_times)
    paramError("reset_time", "List of reset times must be sorted in increasing order");
}

Member Function Documentation

◆ addAssociatedTransfer()

void MultiApp::addAssociatedTransfer ( MultiAppTransfer & transfer )

Add a transfer that is associated with this multiapp.

Definition at line 1510 of file MultiApp.C.

{
  _associated_transfers.push_back(&transfer);
}

◆ appPostprocessorValue()

Real MultiApp::appPostprocessorValue	(	unsigned int	app,
		const std::string &	name
	)

Get a Postprocessor value for a specified global app.

Parameters

app	The global app number you want to get a Postprocessor from.
name	The name of the Postprocessor.

Definition at line 1059 of file MultiApp.C.

{
  if (!_has_an_app)
    mooseError("No app for ", MultiApp::name(), " on processor ", _orig_rank);
 
  return appProblemBase(app).getPostprocessorValueByName(name);
}

◆ appProblem()

FEProblem & MultiApp::appProblem ( unsigned int app )

Get the FEProblem for the global app is part of.

Parameters

app	The global app number

Definition at line 1037 of file MultiApp.C.

{
  mooseDeprecated(
      "MultiApp::appProblem() is deprecated, call MultiApp::appProblemBase() instead.\n");
  if (!_has_an_app)
    mooseError("No app for ", name(), " on processor ", _orig_rank);
 
  unsigned int local_app = globalAppToLocal(app);
 
  return dynamic_cast<FEProblem &>(_apps[local_app]->getExecutioner()->feProblem());
}

◆ appProblemBase()

FEProblemBase & MultiApp::appProblemBase ( unsigned int app )

Get the FEProblemBase for the global app desired.

Parameters

app	The global app number

Definition at line 1026 of file MultiApp.C.

{
  if (!_has_an_app)
    mooseError("No app for ", name(), " on processor ", _orig_rank);
 
  unsigned int local_app = globalAppToLocal(app);
 
  return _apps[local_app]->getExecutioner()->feProblem();
}

Referenced by appPostprocessorValue(), appTransferVector(), TransientMultiApp::appTransferVector(), appUserObjectBase(), FullSolveMultiApp::initialSetup(), TransientMultiApp::resetApp(), TransientMultiApp::setupApp(), FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ appTransferVector()

NumericVector< Number > & MultiApp::appTransferVector	(	unsigned int	app,
		std::string	var_name
	)

virtual

Get the vector to transfer to for this MultiApp.

In general this is the Auxiliary system solution vector.

Parameters

app	The global app number you want the transfer vector for.
var_name	The name of the variable you are going to be transferring to.

Returns: The vector to fill.

Reimplemented in TransientMultiApp.

Definition at line 1068 of file MultiApp.C.

{
  return *(appProblemBase(app).getSystem(var_name).solution);
}

◆ appUserObjectBase()

const UserObject & MultiApp::appUserObjectBase	(	unsigned int	app,
		const std::string &	name
	)

Get a UserObject base for a specific global app.

Parameters

app	The global app number you want to get a UserObject from.
name	The name of the UserObject.

Definition at line 1050 of file MultiApp.C.

{
  if (!_has_an_app)
    mooseError("No app for ", MultiApp::name(), " on processor ", _orig_rank);
 
  return appProblemBase(app).getUserObjectBase(name);
}

◆ backup()

void MultiApp::backup ( )

virtual

Save off the state of every Sub App.

This allows us to "Restore" this state later

Definition at line 769 of file MultiApp.C.

{
  TIME_SECTION(_backup_timer);
 
  if (_fe_problem.verboseMultiApps())
    _console << "Backed up MultiApp ... ";
 
  for (unsigned int i = 0; i < _my_num_apps; i++)
    _sub_app_backups[i] = _apps[i]->backup();
 
  if (_fe_problem.verboseMultiApps())
    _console << name() << std::endl;
}

Referenced by backup(), dataStore(), and preTransfer().

◆ buildComm()

void MultiApp::buildComm ( )

protected

Create an MPI communicator suitable for each app.

Also find out which communicator we are using and what our first local app is.

Definition at line 1444 of file MultiApp.C.

{
  int ierr;
 
  ierr = MPI_Comm_size(_communicator.get(), &_orig_num_procs);
  mooseCheckMPIErr(ierr);
  ierr = MPI_Comm_rank(_communicator.get(), &_orig_rank);
  mooseCheckMPIErr(ierr);
 
#ifdef LIBMESH_HAVE_SYS_UTSNAME_H
  struct utsname sysInfo;
  uname(&sysInfo);
  _node_name = sysInfo.nodename;
#else
  _node_name = "Unknown";
#endif
 
  int rank;
  ierr = MPI_Comm_rank(_communicator.get(), &rank);
  mooseCheckMPIErr(ierr);
 
  _my_num_apps = _rank_config.num_local_apps;
  _first_local_app = _rank_config.first_local_app_index;
 
  _has_an_app = _rank_config.num_local_apps > 0;
  if (_rank_config.first_local_app_index >= _total_num_apps)
    mooseError("Internal error, a processor has an undefined app.");
 
  if (_has_an_app)
  {
    _communicator.split(_rank_config.first_local_app_index, rank, _my_communicator);
    ierr = MPI_Comm_rank(_my_comm, &_my_rank);
    mooseCheckMPIErr(ierr);
  }
  else
  {
    _communicator.split(MPI_UNDEFINED, rank, _my_communicator);
    _my_rank = 0;
  }
}

Referenced by init().

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

◆ cliArgs()

std::vector< std::string > MultiApp::cliArgs ( ) const

protectedvirtual

function that provides cli_args to subapps

Definition at line 1523 of file MultiApp.C.

{
  // So that we can error out with paramError("cli_args", ...);
  _cli_args_param = "cli_args";
  return std::vector<std::string>(_cli_args.begin(), _cli_args.end());
}

Referenced by createApp(), getCommandLineArgs(), init(), and readCommandLineArguments().

◆ comm()

MPI_Comm & MultiApp::comm ( )

inline

Get the MPI communicator this MultiApp is operating on.

Returns: The MPI comm for this MultiApp

Definition at line 352 of file MultiApp.h.

352{ return _my_comm; }

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

◆ createApp()

void MultiApp::createApp	(	unsigned int	i,
		Real	start_time
	)

protected

Helper function for creating an App instance.

Parameters

i	The local app number to create.
start_time	The initial time for the App

Definition at line 1145 of file MultiApp.C.

{
  // Delete the old app if we're resetting
  if (_apps[i])
    _apps[i].reset();
 
  // Define the app name
  const std::string multiapp_name = getMultiAppName(name(), _first_local_app + i, _total_num_apps);
  std::string full_name;
 
  // Only add parent name if the parent is not the main app
  if (_app.multiAppLevel() > 0)
    full_name = _app.name() + "_" + multiapp_name;
  else
    full_name = multiapp_name;
 
  InputParameters app_params = AppFactory::instance().getValidParams(_app_type);
  app_params.set<FEProblemBase *>("_parent_fep") = &_fe_problem;
  app_params.set<std::unique_ptr<Backup> *>("_initial_backup") = &_sub_app_backups[i];
 
  // Build the CommandLine with the relevant options for this subapp and add the
  // cli args from the input file
  std::vector<std::string> input_cli_args;
  if (cliArgs().size() > 0 || _cli_args_from_file.size() > 0)
    input_cli_args = getCommandLineArgs(i);
  // FullSolveMultiApp (and its derived classes) always performs a complete fresh
  // solve on every execution, so the parent's recovery-related global CLI params
  // must not be propagated to those sub-apps.
  const std::set<std::string> recover_exclude =
      propagateRecoverToSubApps()
          ? std::set<std::string>{}
          : std::set<std::string>{"recover", "test_checkpoint_half_transient"};
  // This will mark all hit CLI command line parameters that are passed to subapps
  // as used within the parent app (_app)
  auto app_cli = _app.commandLine()->initSubAppCommandLine(
      name(), multiapp_name, input_cli_args, recover_exclude);
  app_cli->parse();
 
  if (_fe_problem.verboseMultiApps())
    _console << COLOR_CYAN << "Creating MultiApp " << name() << " of type " << _app_type
             << " of level " << _app.multiAppLevel() + 1 << " and number " << _first_local_app + i
             << " on processor " << processor_id() << " with full name " << full_name
             << COLOR_DEFAULT << std::endl;
  app_params.set<unsigned int>("_multiapp_level") = _app.multiAppLevel() + 1;
  app_params.set<unsigned int>("_multiapp_number") = _first_local_app + i;
  app_params.set<const MooseMesh *>("_master_mesh") = &_fe_problem.mesh();
#ifdef MOOSE_MFEM_ENABLED
  // MFEM device must only be set once across all apps
  // FIXME: this required that the base app is an MFEM app; itwill
  // still fail if multiple MFEM sub-apps are launched from a libMesh base app
  if (i == 0)
  {
    app_params.set<std::shared_ptr<mfem::Device>>("_mfem_device") =
        _app.getMFEMDevice(Moose::PassKey<MultiApp>());
    const auto & mfem_device_set = _app.getMFEMDevices(Moose::PassKey<MultiApp>());
    app_params.set<std::set<std::string>>("_mfem_devices") = mfem_device_set;
  }
  else
  {
    app_params.set<std::shared_ptr<mfem::Device>>("_mfem_device") =
        _apps[0]->getMFEMDevice(Moose::PassKey<MultiApp>());
    const auto & mfem_device_set = _apps[0]->getMFEMDevices(Moose::PassKey<MultiApp>());
    app_params.set<std::set<std::string>>("_mfem_devices") = mfem_device_set;
  }
#endif
  if (getParam<bool>("clone_master_mesh") || getParam<bool>("clone_parent_mesh"))
  {
    if (_fe_problem.verboseMultiApps())
      _console << COLOR_CYAN << "Cloned parent app mesh will be used for MultiApp " << name()
               << COLOR_DEFAULT << std::endl;
    app_params.set<bool>("_use_master_mesh") = true;
    auto displaced_problem = _fe_problem.getDisplacedProblem();
    if (displaced_problem)
      app_params.set<const MooseMesh *>("_master_displaced_mesh") = &displaced_problem->mesh();
  }
 
  // If only one input file was provided, use it for all the solves
  const auto input_index = _input_files.size() == 1 ? 0 : _first_local_app + i;
  const auto & input_file = _input_files[input_index];
 
  // create new parser tree for the application and parse
  auto parser = std::make_unique<Parser>(input_file);
  parser->setCommandLineParams(app_cli->buildHitParams());
  parser->parse();
 
  // Checks on app type
  const auto & app_type = parser->getAppType();
  if (app_type.empty() && _app_type.empty())
    mooseWarning("The application type is not specified for ",
                 full_name,
                 ". Please use [Application] block to specify the application type.");
  if (!app_type.empty() && app_type != _app_type && !AppFactory::instance().isRegistered(app_type))
    mooseError("In the ",
               full_name,
               ", '",
               app_type,
               "' is not a registered application. The registered application is named: '",
               _app_type,
               "'. Please double check the [Application] block to make sure the correct "
               "application is provided. \n");
 
  if (parser->getAppType().empty())
    parser->setAppType(_app_type);
 
  app_params.set<std::shared_ptr<Parser>>("_parser") = std::move(parser);
  app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(app_cli);
  _apps[i] = AppFactory::instance().create(_app_type, full_name, app_params, _my_comm);
  auto & app = _apps[i];
 
  app->setGlobalTimeOffset(start_time);
  app->setOutputFileNumbers(_app.getOutputWarehouse().getFileNumbers());
  app->setRestart(_app.isRestarting());
  app->setRecover(propagateRecoverToSubApps() && _app.isRecovering());
 
  if (_use_positions && getParam<bool>("output_in_position"))
    app->setOutputPosition(_app.getOutputPosition() + _positions[_first_local_app + i]);
  if (_output_in_position && _run_in_position)
    paramError("run_in_position",
               "Sub-apps are already displaced, so they are already output in position");
 
  // Update the MultiApp level for the app that was just created
  app->setupOptions();
  // if multiapp does not have file base in Outputs input block, output file base will
  // be empty here since setupOptions() does not set the default file base with the multiapp
  // input file name. Parent app will create the default file base for multiapp by taking the
  // output base of the parent app problem and appending the name of the multiapp plus a number to
  // it
  if (app->getOutputFileBase().empty())
    setAppOutputFileBase(i);
  preRunInputFile();
  if (_app.multiAppLevel() > getParam<unsigned int>("max_multiapp_level"))
    mooseError("Maximum multiapp level has been reached. This is likely caused by an infinite loop "
               "in your multiapp system. If additional multiapp levels are needed, "
               "max_multiapp_level can be specified in the MuliApps block.");
 
  // Transfer coupling relaxation information to the subapps
  _apps[i]->fixedPointConfig().sub_relaxation_factor = getParam<Real>("relaxation_factor");
  _apps[i]->fixedPointConfig().sub_transformed_vars =
      getParam<std::vector<std::string>>("transformed_variables");
  // Handle deprecated parameter
  if (!parameters().isParamSetByAddParam("relaxed_variables"))
    _apps[i]->fixedPointConfig().sub_transformed_vars =
        getParam<std::vector<std::string>>("relaxed_variables");
  _apps[i]->fixedPointConfig().sub_transformed_pps =
      getParam<std::vector<PostprocessorName>>("transformed_postprocessors");
 
  app->runInputFile();
  auto fixed_point_solve = &(_apps[i]->getExecutioner()->fixedPointSolve());
  if (fixed_point_solve)
    fixed_point_solve->allocateStorage(false);
 
  // Transform the app mesh if requested
  if (_run_in_position)
  {
    auto & mesh = app->getExecutioner()->feProblem().mesh();
    if (usingPositions())
      app->getExecutioner()->feProblem().coordTransform().transformMesh(
          mesh, _positions[_first_local_app + i]);
    else
      app->getExecutioner()->feProblem().coordTransform().transformMesh(mesh, Point(0, 0, 0));
 
    // Transforming marks mesh->spatial_dimension() as invalid, so we
    // reprepare before trying to print that later.
    mesh.getMesh().complete_preparation();
  }
}

Referenced by createLocalApp(), and resetApp().

◆ createApps()

void MultiApp::createApps ( )

protected

Create the provided number of apps.

This is called in the setupPositions().

Definition at line 392 of file MultiApp.C.

{
  if (!_has_an_app)
    return;
 
  TIME_SECTION("createApps", 2, "Instantiating Sub-Apps", false);
 
  // Read commandLine arguments that will be used when creating apps
  readCommandLineArguments();
 
  Moose::ScopedCommSwapper swapper(_my_comm);
 
  _apps.resize(_my_num_apps);
 
  // If the user provided an unregistered app type, see if we can load it dynamically
  if (!AppFactory::instance().isRegistered(_app_type))
    _app.dynamicAppRegistration(_app_type,
                                getParam<std::string>("library_path"),
                                getParam<std::string>("library_name"),
                                getParam<bool>("library_load_dependencies"));
 
  bool rank_did_quiet_init = false;
  unsigned int local_app = libMesh::invalid_uint;
  if (_wait_for_first_app_init)
  {
    if (hasLocalApp(0))
    {
      rank_did_quiet_init = true;
      local_app = globalAppToLocal(0);
      createLocalApp(local_app);
    }
 
    MPI_Barrier(_orig_comm);
  }
 
  for (unsigned int i = 0; i < _my_num_apps; i++)
  {
    if (rank_did_quiet_init && i == local_app)
      continue;
    createLocalApp(i);
  }
}

Referenced by initialSetup(), and setupPositions().

◆ createLocalApp()

void MultiApp::createLocalApp ( const unsigned int i )

virtual

Create the i-th local app.

Parameters

[in] i local app index

Definition at line 436 of file MultiApp.C.

{
  createApp(i, _global_time_offset);
}

Referenced by createApps().

◆ 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 = cast_ref<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;
}

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

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

◆ fillPositions()

void MultiApp::fillPositions ( )

protectedvirtual

must fill in _positions with the positions of the sub-aps

Reimplemented in CentroidMultiApp, and QuadraturePointMultiApp.

Definition at line 549 of file MultiApp.C.

{
  if (_move_apps.size() != _move_positions.size())
    mooseError("The number of apps to move and the positions to move them to must be the same for "
               "MultiApp ",
               _name);
 
  if (isParamValid("positions") + isParamValid("positions_file") +
          isParamValid("positions_objects") >
      1)
    mooseError("Only one 'positions' parameter may be specified");
 
  if (isParamValid("positions"))
  {
    _positions = getParam<std::vector<Point>>("positions");
 
    if (_positions.size() < _input_files.size())
      mooseError("Not enough positions for the number of input files provided in MultiApp ",
                 name());
  }
  else if (isParamValid("positions_file"))
  {
    std::vector<FileName> positions_files = getParam<std::vector<FileName>>("positions_file");
    std::vector<FileName> input_files = getParam<std::vector<FileName>>("input_files");
 
    if (input_files.size() != 1 && positions_files.size() != input_files.size())
      mooseError("Number of input_files for MultiApp ",
                 name(),
                 " must either be only one or match the number of positions_file files");
 
    // Clear out the _input_files because we're going to rebuild it
    if (input_files.size() != 1)
      _input_files.clear();
 
    for (unsigned int p_file_it = 0; p_file_it < positions_files.size(); p_file_it++)
    {
      std::string positions_file = positions_files[p_file_it];
      MooseUtils::DelimitedFileReader file(positions_file, &_communicator);
      file.setFormatFlag(MooseUtils::DelimitedFileReader::FormatFlag::ROWS);
      file.read();
 
      const std::vector<Point> & data = file.getDataAsPoints();
      for (const auto & d : data)
        _positions.push_back(d);
 
      // Save the number of positions for this input file
      _npositions_inputfile.push_back(data.size());
 
      for (unsigned int i = 0; i < data.size(); ++i)
        if (input_files.size() != 1)
          _input_files.push_back(input_files[p_file_it]);
    }
  }
  else if (isParamValid("positions_objects"))
  {
    const auto & positions_param_objs = getParam<std::vector<PositionsName>>("positions_objects");
    const auto & input_files = getParam<std::vector<FileName>>("input_files");
 
    if (input_files.size() != 1 && positions_param_objs.size() != input_files.size())
      mooseError("Number of input_files for MultiApp ",
                 name(),
                 " must either be only one or match the number of positions_objects specified");
 
    // Clear out the _input_files because we're going to rebuild it
    if (input_files.size() != 1)
      _input_files.clear();
 
    // Keeps track of where each positions object start in terms of subapp numbers
    unsigned int offset = 0;
 
    for (const auto p_obj_it : index_range(positions_param_objs))
    {
      const std::string & positions_name = positions_param_objs[p_obj_it];
      auto positions_obj = &_fe_problem.getPositionsObject(positions_name);
 
      const auto & data = positions_obj->getPositions(true);
 
      // Append all positions from this object
      for (const auto & d : data)
        _positions.push_back(d);
 
      // Save the number of positions for this input file
      _npositions_inputfile.push_back(data.size());
 
      if (!positions_obj)
        paramError("positions_objects",
                   "'" + positions_name + "' is not of the expected type. Should be a Positions");
 
      // Keep track of which positions is tied to what subapp
      for (unsigned int i = 0; i < data.size(); ++i)
      {
        if (input_files.size() != 1)
          _input_files.push_back(input_files[p_obj_it]);
        _positions_objs.push_back(positions_obj);
        _positions_index_offsets.push_back(offset);
      }
      offset += data.size();
    }
  }
  else
  {
    _positions = {Point()};
 
    if (_positions.size() < _input_files.size())
      mooseError("Not enough positions for the number of input files provided in MultiApp ",
                 name());
  }
 
  mooseAssert(_input_files.size() == 1 || _positions.size() == _input_files.size(),
              "Number of positions and input files are not the same!");
}

Referenced by setupPositions().

◆ finalize()

void MultiApp::finalize ( )

virtual

Method called towards the end of the simulation to execute on final.

Reimplemented in FullSolveMultiApp.

Definition at line 744 of file MultiApp.C.

{
  for (const auto & app_ptr : _apps)
  {
    auto * executioner = app_ptr->getExecutioner();
    mooseAssert(executioner, "Executioner is nullptr");
 
    executioner->feProblem().execute(EXEC_FINAL);
    executioner->feProblem().outputStep(EXEC_FINAL);
  }
}

◆ finishStep()

virtual void MultiApp::finishStep ( bool = false )

inlinevirtual

Calls multi-apps executioners' endStep and postStep methods which creates output and advances time (not the time step; see incrementTStep()) among other things.

This method is only called for Picard calculations because for loosely coupled calculations the executioners' endStep and postStep methods are called from solveStep(). This may be called with the optional flag recurse_through_multiapp_levels which may be useful if this method is being called for the final time of program execution

Reimplemented in TransientMultiApp.

Definition at line 188 of file MultiApp.h.

188{}

◆ firstLocalApp()

unsigned int MultiApp::firstLocalApp ( )

inline

Returns: The global number of the first app on the local processor.

Definition at line 288 of file MultiApp.h.

288{ return _first_local_app; }

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

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

◆ getBoundingBox()

BoundingBox MultiApp::getBoundingBox	(	unsigned int	app,
		bool	displaced_mesh,
		const MultiAppCoordTransform *	coord_transform = `nullptr`
	)

virtual

Get the BoundingBox for the mesh associated with app The bounding box will be shifted to be in the correct position within the master domain.

If the MultiApp is in an RZ coordinate system the box will be the size it would be if the geometry were 3D (ie if you were to revolve the geometry around the axis to create the 3D geometry).

Parameters

app	The global app number you want to get the bounding box for
displaced_mesh	True if the bounding box is retrieved for the displaced mesh, other false
coord_transform	An optional coordinate transformation object

Definition at line 952 of file MultiApp.C.

{
  if (!_has_an_app)
    mooseError("No app for ", name(), " on processor ", _orig_rank);
 
  unsigned int local_app = globalAppToLocal(app);
  FEProblemBase & fe_problem_base = _apps[local_app]->getExecutioner()->feProblem();
  MooseMesh & mesh = (displaced_mesh && fe_problem_base.getDisplacedProblem().get() != NULL)
                         ? fe_problem_base.getDisplacedProblem()->mesh()
                         : fe_problem_base.mesh();
 
  {
    Moose::ScopedCommSwapper swapper(_my_comm);
    if (displaced_mesh)
      _bounding_box[local_app] = MeshTools::create_bounding_box(mesh);
    else
    {
      if (!_has_bounding_box[local_app])
      {
        _bounding_box[local_app] = MeshTools::create_bounding_box(mesh);
        _has_bounding_box[local_app] = true;
      }
    }
  }
  BoundingBox bbox = _bounding_box[local_app];
 
  Point min = bbox.min();
  min -= _bounding_box_padding;
  Point max = bbox.max();
  max += _bounding_box_padding;
 
  Point inflation_amount = (max - min) * _inflation;
 
  Point inflated_min = min - inflation_amount;
  Point inflated_max = max + inflation_amount;
 
  Point shifted_min = inflated_min;
  Point shifted_max = inflated_max;
 
  if ((!coord_transform || coord_transform->skipCoordinateCollapsing()) &&
      fe_problem_base.getCoordSystem(*(mesh.meshSubdomains().begin())) == Moose::COORD_RZ)
  {
    // If the problem is RZ then we're going to invent a box that would cover the whole "3D" app
    // FIXME: Assuming all subdomains are the same coordinate system type!
    shifted_min(0) = -inflated_max(0);
    shifted_min(1) = inflated_min(1);
    shifted_min(2) = -inflated_max(0);
 
    shifted_max(0) = inflated_max(0);
    shifted_max(1) = inflated_max(1);
    shifted_max(2) = inflated_max(0);
  }
 
  if (coord_transform)
  {
    BoundingBox transformed_bbox(shifted_min, shifted_max);
    transformBoundingBox(transformed_bbox, *coord_transform);
    return transformed_bbox;
  }
  else
  {
    // This is where the app is located.  We need to shift by this amount.
    Point p = position(app);
 
    // Shift them to the position they're supposed to be
    shifted_min += p;
    shifted_max += p;
    return BoundingBox(shifted_min, shifted_max);
  }
}

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

◆ getCommandLineArgs()

std::vector< std::string > MultiApp::getCommandLineArgs ( const unsigned int local_app )

protectedvirtual

Returns: The command line arguments to be applied to the subapp with index local_app

The method is virtual because it is needed to allow for batch runs within the stochastic tools module; see SamplerFullSolveMultiApp for an example.

Definition at line 1313 of file MultiApp.C.

{
  const auto cla = cliArgs();
  auto cli_args_param = _cli_args_param;
  std::string combined_args;
 
  // Single set of args from cliArgs() to be provided to all apps
  if (cla.size() == 1)
    combined_args = cla[0];
  // Single "cli_args_files" file to be provided to all apps
  else if (_cli_args_from_file.size() == 1)
  {
    cli_args_param = "cli_args_files";
    combined_args = _cli_args_from_file[0];
  }
  // Unique set of args from cliArgs() to be provided to each app
  else if (cla.size())
    combined_args = cla[local_app + _first_local_app];
  // Unique set of args from "cli_args_files" to be provided to all apps
  else
  {
    cli_args_param = "cli_args_files";
    combined_args = _cli_args_from_file[local_app + _first_local_app];
  }
 
  // Remove all of the beginning and end whitespace so we can recognize truly empty
  combined_args = MooseUtils::trim(combined_args);
 
  // MooseUtils::split will return a single empty entry if there is nothing,
  // so exit early if we have nothing
  if (combined_args.empty())
    return {};
 
  // Split the argument into a vector of arguments, and make sure
  // that we don't have any empty arguments
  const auto args = MooseUtils::split(combined_args, ";");
  for (const auto & arg : args)
  {
    if (arg.empty())
    {
      const auto error = "An empty MultiApp command line argument was provided. Your "
                         "combined command line string has a ';' with no argument after it.";
      if (cli_args_param)
        paramError(*cli_args_param, error);
      else
        mooseError(error);
    }
  }
 
  return args;
}

Referenced by createApp().

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

◆ 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(), MultiAppTransfer::MultiAppTransfer(), Exodus::outputSetup(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), NodalReporter::shouldStore(), and PIDTransientControl::timestepSetup().

◆ getExecutioner()

Executioner * MultiApp::getExecutioner ( unsigned int app )

virtual

Parameters

app	The global app number to get the Executioner for

Returns: The Executioner associated with that App.

Definition at line 735 of file MultiApp.C.

{
  if (!_has_an_app)
    mooseError("No app for ", name(), " on processor ", _orig_rank);
 
  return _apps[globalAppToLocal(app)]->getExecutioner();
}

Referenced by restore().

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

◆ 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(), preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), LinearFVGradientInterface::resolveFVGradientMethod(), restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

◆ getMultiAppName()

std::string MultiApp::getMultiAppName	(	const std::string &	base_name,
		dof_id_type	index,
		dof_id_type	total
	)

staticprotected

Helper for constructing the name of the multiapp.

Parameters

base_name	The base name of the multiapp, usually name()
index	The index of the app
total	The total number of apps, which is used to pad the name with zeros

Returns: std::string The name of the multiapp

Definition at line 1539 of file MultiApp.C.

{
  std::ostringstream multiapp_name;
  multiapp_name << base_name << std::setw(std::ceil(std::log10(total))) << std::setprecision(0)
                << std::setfill('0') << std::right << index;
  return multiapp_name.str();
}

Referenced by createApp(), and setAppOutputFileBase().

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

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

◆ globalAppToLocal()

unsigned int MultiApp::globalAppToLocal ( unsigned int global_app )

protected

Map a global App number to the local number.

Note: This will error if given a global number that doesn't map to a local number.

Parameters

global_app The global app number.

Returns: The local app number.

Definition at line 1486 of file MultiApp.C.

{
  if (global_app >= _first_local_app && global_app <= _first_local_app + (_my_num_apps - 1))
    return global_app - _first_local_app;
 
  std::stringstream ss;
  ss << "Requesting app " << global_app << ", but processor " << processor_id() << " ";
  if (_my_num_apps == 0)
    ss << "does not own any apps";
  else if (_my_num_apps == 1)
    ss << "owns app " << _first_local_app;
  else
    ss << "owns apps " << _first_local_app << "-" << _first_local_app + (_my_num_apps - 1);
  ss << ".";
  mooseError("Invalid global_app!\n", ss.str());
  return 0;
}

Referenced by appProblem(), appProblemBase(), createApps(), getBoundingBox(), getExecutioner(), moveApp(), TransientMultiApp::resetApp(), and resetApp().

◆ hasApp()

bool MultiApp::hasApp ( )

inline

Whether or not this MultiApp has an app on this processor.

Definition at line 298 of file MultiApp.h.

298{ return _has_an_app; }

◆ 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

◆ hasLocalApp()

bool MultiApp::hasLocalApp ( unsigned int global_app ) const

Whether or not the given global app number is on this processor.

Parameters

global_app The global app number in question

Returns: True if the global app is on this processor

Definition at line 1080 of file MultiApp.C.

{
  if (_has_an_app && global_app >= _first_local_app &&
      global_app <= _first_local_app + (_my_num_apps - 1))
    return true;
 
  return false;
}

Referenced by createApps(), moveApp(), TransientMultiApp::resetApp(), and resetApp().

◆ incrementTStep()

virtual void MultiApp::incrementTStep ( Real )

inlinevirtual

Advances the multi-apps time step which is important for dt selection.

(Note this does not advance the time. That is done in Transient::endStep, which is called either directly from solveStep() for loose coupling cases or through finishStep() for Picard coupling cases)

Reimplemented in TransientMultiApp.

Definition at line 178 of file MultiApp.h.

178{}

◆ init() [1/2]

void MultiApp::init	(	unsigned int	num_apps,
		bool	batch_mode = `false`
	)

protected

Build communicators and reserve backups.

Definition at line 344 of file MultiApp.C.

{
  auto config = rankConfig(
      processor_id(), n_processors(), num_apps, _min_procs_per_app, _max_procs_per_app, batch_mode);
  init(num_apps, config);
}

Referenced by init(), and setupPositions().

◆ init() [2/2]

void MultiApp::init	(	unsigned int	num_apps,
		const LocalRankConfig &	config
	)

protected

Same as other init method, except defining a custom rank configuration.

Definition at line 352 of file MultiApp.C.

{
  TIME_SECTION(_init_timer);
 
  _total_num_apps = num_apps;
  _rank_config = config;
  buildComm();
  _sub_app_backups.resize(_my_num_apps);
 
  _has_bounding_box.resize(_my_num_apps, false);
  _reset_happened.resize(_reset_times.size(), false);
  _bounding_box.resize(_my_num_apps);
 
  if ((_cli_args.size() > 1) && (_total_num_apps != _cli_args.size()))
    paramError("cli_args",
               "The number of items supplied must be 1 or equal to the number of sub apps.");
 
  // if cliArgs() != _cli_args, then cliArgs() was overridden and we need to check it
  auto cla = cliArgs();
  if (cla != std::vector<std::string>(_cli_args.begin(), _cli_args.end()))
  {
    if ((cla.size() > 1) && (_total_num_apps != cla.size()))
      mooseError("The number of items supplied as command line argument to subapps must be 1 or "
                 "equal to the number of sub apps. Note: you use a multiapp that provides its own "
                 "command line parameters so the error is not in cli_args");
  }
}

◆ initialSetup()

void MultiApp::initialSetup ( )

overridevirtual

Method to be called in main-app initial setup for create sub-apps if using positions is false.

Reimplemented from SetupInterface.

Reimplemented in FullSolveMultiApp, and TransientMultiApp.

Definition at line 442 of file MultiApp.C.

{
  if (!_use_positions)
    // if not using positions, we create the sub-apps in initialSetup instead of right after
    // construction of MultiApp
    createApps();
}

Referenced by FullSolveMultiApp::initialSetup(), and TransientMultiApp::initialSetup().

◆ isFirstLocalRank()

bool MultiApp::isFirstLocalRank ( ) const

Returns: Whether this rank is the first rank of the subapp(s) it's involved in

Definition at line 1074 of file MultiApp.C.

{
  return _rank_config.is_first_local_rank;
}

◆ 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(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), 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); }

◆ isRootProcessor()

bool MultiApp::isRootProcessor ( )

inline

Whether or not this processor is the "root" processor for the sub communicator.

The "root" processor has rank 0 in the sub communicator

Definition at line 358 of file MultiApp.h.

358{ return _my_rank == 0; }

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

◆ keepSolutionDuringRestore()

void MultiApp::keepSolutionDuringRestore ( bool keep_solution_during_restore )

protected

Preserve the solution from the previous simulation, and it is used as an initial guess for the next run.

Definition at line 902 of file MultiApp.C.

{
  if (_pars.isParamSetByUser("keep_solution_during_restore"))
    paramError("keep_solution_during_restore",
               "This parameter should only be provided in parent app");
 
  _keep_solution_during_restore = keep_solution_during_restore;
}

◆ localApp()

MooseApp * MultiApp::localApp ( unsigned int local_app )

Get the local MooseApp object.

Parameters

local_app The local app number

Definition at line 1090 of file MultiApp.C.

{
  mooseAssert(local_app < _apps.size(), "Index out of range: " + Moose::stringify(local_app));
  return _apps[local_app].get();
}

◆ 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 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(), 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(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MFEMRefinementMarker::MFEMRefinementMarker(), 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");
  }

◆ moveApp()

void MultiApp::moveApp	(	unsigned int	global_app,
		Point	p
	)

virtual

Move the global_app to Point p.

Parameters

global_app	The global app number in question
p	The new position of the App.

Definition at line 1118 of file MultiApp.C.

{
  if (_use_positions)
  {
    _positions[global_app] = p;
 
    if (hasLocalApp(global_app))
    {
      unsigned int local_app = globalAppToLocal(global_app);
 
      if (_output_in_position)
        _apps[local_app]->setOutputPosition(p);
      if (_run_in_position)
        paramError("run_in_position", "Moving apps and running apps in position is not supported");
    }
  }
}

Referenced by preTransfer().

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

◆ needsRestoration()

bool MultiApp::needsRestoration ( )

inline

Whether or not this MultiApp should be restored at the beginning of each Picard iteration.

Definition at line 210 of file MultiApp.h.

210{ return !_no_restore; }

Referenced by restore().

◆ numGlobalApps()

unsigned int MultiApp::numGlobalApps ( ) const

inline

Returns: Number of Global Apps in this MultiApp

Definition at line 278 of file MultiApp.h.

278{ return _total_num_apps; }

◆ numLocalApps()

unsigned int MultiApp::numLocalApps ( )

inline

Returns: Number of Apps on local processor.

Definition at line 283 of file MultiApp.h.

283{ return _apps.size(); }

◆ 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(), CylindricalGridDivision::CylindricalGridDivision(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), MultiAppTransfer::MultiAppTransfer(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

◆ parentOutputPositionChanged()

void MultiApp::parentOutputPositionChanged ( )

virtual

For apps outputting in position we need to change their output positions if their parent app moves.

Definition at line 1137 of file MultiApp.C.

{
  if (_use_positions && _output_in_position)
    for (unsigned int i = 0; i < _apps.size(); i++)
      _apps[i]->setOutputPosition(_app.getOutputPosition() + _positions[_first_local_app + i]);
}

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

◆ position()

const Point & MultiApp::position ( unsigned int app ) const

The physical position of a global App number.

Parameters

app	The global app number you want the position for.

Returns: the position

Definition at line 1548 of file MultiApp.C.

{
  // If we're not using positions, it won't have changed
  if (_positions_objs.empty())
    return _positions[app];
  else
    // Find which Positions object is specifying it, and query a potentially updated value
    return _positions_objs[app]->getPosition(app - _positions_index_offsets[app], false);
}

Referenced by getBoundingBox().

◆ postExecute()

void MultiApp::postExecute ( )

virtual

Method called at the end of the simulation (after finalize).

Reimplemented in FullSolveMultiApp.

Definition at line 757 of file MultiApp.C.

{
  for (const auto & app_ptr : _apps)
  {
    auto * executioner = app_ptr->getExecutioner();
    mooseAssert(executioner, "Executioner is nullptr");
 
    executioner->postExecute();
  }
}

◆ preExecute()

virtual void MultiApp::preExecute ( )

inlinevirtual

Definition at line 122 of file MultiApp.h.

122{}

◆ preRunInputFile()

void MultiApp::preRunInputFile ( )

protectedvirtual

call back executed right before app->runInputFile()

Definition at line 1505 of file MultiApp.C.

1506{

1507}

Referenced by createApp().

◆ preTransfer()

void MultiApp::preTransfer	(	Real	dt,
		Real	target_time
	)

virtual

Gets called just before transfers are done to the MultiApp (Which is just before the MultiApp is solved).

Definition at line 662 of file MultiApp.C.

{
  // Get a transient executioner to get a user-set tolerance
  Real timestep_tol = 1e-13;
  if (dynamic_cast<TransientBase *>(_fe_problem.getMooseApp().getExecutioner()))
    timestep_tol =
        dynamic_cast<TransientBase *>(_fe_problem.getMooseApp().getExecutioner())->timestepTol();
 
  // Determination on whether we need to backup the app due to changes below
  bool backup_apps = false;
 
  // First, see if any Apps need to be reset
  for (unsigned int i = 0; i < _reset_times.size(); i++)
  {
    if (!_reset_happened[i] && (target_time + timestep_tol >= _reset_times[i]))
    {
      _reset_happened[i] = true;
      if (_reset_apps.size() > 0)
        for (auto & app : _reset_apps)
          resetApp(app);
 
      // If we reset an application, then we delete the old objects, including the coordinate
      // transformation classes. Consequently we need to reset the coordinate transformation classes
      // in the associated transfer classes
      for (auto * const transfer : _associated_transfers)
        transfer->getAppInfo();
 
      // Similarly we need to transform the mesh again
      if (_run_in_position)
        for (const auto i : make_range(_my_num_apps))
        {
          auto app_ptr = _apps[i];
          auto & mesh = app_ptr->getExecutioner()->feProblem().mesh();
          if (usingPositions())
            app_ptr->getExecutioner()->feProblem().coordTransform().transformMesh(
                mesh, _positions[_first_local_app + i]);
          else
            app_ptr->getExecutioner()->feProblem().coordTransform().transformMesh(mesh,
                                                                                  Point(0, 0, 0));
 
          // Transforming marks mesh->spatial_dimension() as invalid,
          // so we reprepare before trying to print that later.
          mesh.getMesh().complete_preparation();
        }
 
      // If the time step covers multiple reset times, set them all as having 'happened'
      for (unsigned int j = i; j < _reset_times.size(); j++)
        if (target_time + timestep_tol >= _reset_times[j])
          _reset_happened[j] = true;
 
      // Backup in case the next solve fails
      backup_apps = true;
 
      break;
    }
  }
 
  // Now move any apps that should be moved
  if (_use_positions && !_move_happened && target_time + timestep_tol >= _move_time)
  {
    _move_happened = true;
    for (unsigned int i = 0; i < _move_apps.size(); i++)
      moveApp(_move_apps[i], _move_positions[i]);
 
    // Backup in case the next solve fails
    backup_apps = true;
  }
 
  if (backup_apps)
    backup();
}

◆ problemBase()

FEProblemBase & MultiApp::problemBase ( )

inline

Get the FEProblemBase this MultiApp is part of.

Definition at line 237 of file MultiApp.h.

237{ return _fe_problem; }

◆ propagateRecoverToSubApps()

virtual bool MultiApp::propagateRecoverToSubApps ( ) const

inlineprotectedvirtual

Whether or not to propagate the parent's recover state (the –recover and –test-checkpoint-half-transient flags) to sub-applications.

Returns true for all MultiApps except FullSolveMultiApp and its derived classes. FullSolveMultiApp always performs a complete fresh solve on every execution and must never recover its sub-apps from a checkpoint. Note that restart propagation (setRestart) is deliberately not gated here because a FullSolveMultiApp sub-app may legitimately be restarted from a user-specified restart file.

Reimplemented in FullSolveMultiApp.

Definition at line 421 of file MultiApp.h.

421{ return true; }

Referenced by createApp().

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

◆ readCommandLineArguments()

void MultiApp::readCommandLineArguments ( )

protected

Fill command line arguments for sub apps.

Definition at line 451 of file MultiApp.C.

{
  if (isParamValid("cli_args_files"))
  {
    _cli_args_from_file.clear();
 
    std::vector<FileName> cli_args_files = getParam<std::vector<FileName>>("cli_args_files");
    std::vector<FileName> input_files = getParam<std::vector<FileName>>("input_files");
 
    // If we use parameter "cli_args_files", at least one file should be provided
    if (!cli_args_files.size())
      paramError("cli_args_files", "You need to provide at least one commandLine argument file ");
 
    // If we multiple input files, then we need to check if the number of input files
    // match with the number of argument files
    if (cli_args_files.size() != 1 && cli_args_files.size() != input_files.size())
      paramError("cli_args_files",
                 "The number of commandLine argument files ",
                 cli_args_files.size(),
                 " for MultiApp ",
                 name(),
                 " must either be only one or match the number of input files ",
                 input_files.size());
 
    // Go through all argument files
    std::vector<std::string> cli_args;
    for (unsigned int p_file_it = 0; p_file_it < cli_args_files.size(); p_file_it++)
    {
      std::string cli_args_file = cli_args_files[p_file_it];
      // Clear up
      cli_args.clear();
      // Read the file on the root processor then broadcast it
      if (processor_id() == 0)
      {
        MooseUtils::checkFileReadable(cli_args_file);
 
        std::ifstream is(cli_args_file.c_str());
        // Read by line rather than space separated like the cli_args parameter
        std::string line;
        while (std::getline(is, line))
          cli_args.push_back(line);
 
        // We do not allow empty files
        if (!cli_args.size())
          paramError("cli_args_files",
                     "There is no commandLine argument in the commandLine argument file ",
                     cli_args_file);
 
        // If we have position files, we need to
        // make sure the number of commandLine argument strings
        // match with the number of positions
        if (_npositions_inputfile.size())
        {
          auto num_positions = _npositions_inputfile[p_file_it];
          // Check if the number of commandLine argument strings equal to
          // the number of positions
          if (cli_args.size() == 1)
            for (MooseIndex(num_positions) num = 0; num < num_positions; num++)
              _cli_args_from_file.push_back(cli_args.front());
          else if (cli_args.size() == num_positions)
            for (auto && cli_arg : cli_args)
              _cli_args_from_file.push_back(cli_arg);
          else if (cli_args.size() != num_positions)
            paramError("cli_args_files",
                       "The number of commandLine argument strings ",
                       cli_args.size(),
                       " in the file ",
                       cli_args_file,
                       " must either be only one or match the number of positions ",
                       num_positions);
        }
        else
        {
          // If we do not have position files, we will check if the number of
          // commandLine argument strings match with the total number of subapps
          for (auto && cli_arg : cli_args)
            _cli_args_from_file.push_back(cli_arg);
        }
      }
    }
 
    // Broad cast all arguments to everyone
    _communicator.broadcast(_cli_args_from_file);
  }
 
  if (_cli_args_from_file.size() && _cli_args_from_file.size() != 1 &&
      _cli_args_from_file.size() != _total_num_apps)
    mooseError(" The number of commandLine argument strings ",
               _cli_args_from_file.size(),
               " must either be only one or match the total "
               "number of sub apps ",
               _total_num_apps);
 
  if (_cli_args_from_file.size() && cliArgs().size())
    mooseError("Cannot set commandLine arguments from both input_file and external files");
}

Referenced by createApps().

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

◆ resetApp()

void MultiApp::resetApp	(	unsigned int	global_app,
		Real	time = `0.0`
	)

virtual

"Reset" the App corresponding to the global App number passed in.

"Reset" means that the App will be deleted and recreated. The time for the new App will be set to the current simulation time. This might be handy if some sub-app in your simulation needs to get replaced by a "new" piece of material.

Parameters

global_app	The global app number to reset.
time	The time to set as the the time for the new app, this should really be the time the old app was at.

Reimplemented in TransientMultiApp.

Definition at line 1097 of file MultiApp.C.

{
  TIME_SECTION(_reset_timer);
 
  Moose::ScopedCommSwapper swapper(_my_comm);
 
  if (hasLocalApp(global_app))
  {
    unsigned int local_app = globalAppToLocal(global_app);
 
    // Extract the file numbers from the output, so that the numbering is maintained after reset
    std::map<std::string, unsigned int> m = _apps[local_app]->getOutputWarehouse().getFileNumbers();
 
    createApp(local_app, time);
 
    // Reset the file numbers of the newly reset apps
    _apps[local_app]->getOutputWarehouse().setFileNumbers(m);
  }
}

Referenced by preTransfer(), and TransientMultiApp::resetApp().

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

◆ restore()

void MultiApp::restore ( bool force = true )

virtual

Restore the state of every Sub App.

This allows us to "Restore" this state later If the app is not forced to restore, it is only done as needed (and also for the apps underneath as needed)

Parameters

force Whether the restoration has to happen no matter what.

Reimplemented in FullSolveMultiApp.

Definition at line 784 of file MultiApp.C.

{
  TIME_SECTION(_restore_timer);
 
  if (force || needsRestoration())
  {
    // Must be restarting / recovering from main app so hold off on restoring
    // Instead - the restore will happen in sub-apps' initialSetup()
    // Note that _backups was already populated by dataLoad() in the main app
    if (_fe_problem.getCurrentExecuteOnFlag() == EXEC_INITIAL)
      return;
 
    // We temporarily copy and store solutions for all subapps
    if (_keep_solution_during_restore)
    {
      _end_solutions.resize(_my_num_apps);
 
      for (unsigned int i = 0; i < _my_num_apps; i++)
      {
        _end_solutions[i].resize(_apps[i]->getExecutioner()->feProblem().numSolverSystems());
        for (unsigned int j = 0; j < _apps[i]->getExecutioner()->feProblem().numSolverSystems();
             j++)
        {
          _end_solutions[i][j] = _apps[i]
                                     ->getExecutioner()
                                     ->feProblem()
                                     .getSolverSystem(/*solver_sys=*/j)
                                     .solution()
                                     .clone();
        }
        auto & sub_multiapps =
            _apps[i]->getExecutioner()->feProblem().getMultiAppWarehouse().getObjects();
 
        // multiapps of each subapp should do the same things
        // It is implemented recursively
        for (auto & multi_app : sub_multiapps)
          multi_app->keepSolutionDuringRestore(_keep_solution_during_restore);
      }
    }
 
    // We temporarily copy and store solutions for all subapps
    if (_keep_aux_solution_during_restore)
    {
      _end_aux_solutions.resize(_my_num_apps);
 
      for (unsigned int i = 0; i < _my_num_apps; i++)
        _end_aux_solutions[i] =
            _apps[i]->getExecutioner()->feProblem().getAuxiliarySystem().solution().clone();
    }
 
    if (_fe_problem.verboseMultiApps())
      _console << "Restoring MultiApp ... ";
 
    for (unsigned int i = 0; i < _my_num_apps; i++)
    {
      _apps[i]->restore(std::move(_sub_app_backups[i]), false);
      _sub_app_backups[i] = _apps[i]->finalizeRestore();
      mooseAssert(_sub_app_backups[i], "Should have a backup");
    }
 
    if (_fe_problem.verboseMultiApps())
      _console << name() << std::endl;
 
    // Now copy the latest solutions back for each subapp
    if (_keep_solution_during_restore)
    {
      for (unsigned int i = 0; i < _my_num_apps; i++)
      {
        for (unsigned int j = 0; j < _apps[i]->getExecutioner()->feProblem().numSolverSystems();
             j++)
        {
          _apps[i]->getExecutioner()->feProblem().getSolverSystem(/*solver_sys=*/j).solution() =
              *_end_solutions[i][j];
 
          // We need to synchronize solution so that local_solution has the right values
          _apps[i]->getExecutioner()->feProblem().getSolverSystem(/*solver_sys=*/j).update();
        }
      }
 
      _end_solutions.clear();
    }
    // Now copy the latest auxiliary solutions back for each subapp
    if (_keep_aux_solution_during_restore)
    {
      for (unsigned int i = 0; i < _my_num_apps; i++)
      {
        _apps[i]->getExecutioner()->feProblem().getAuxiliarySystem().solution() =
            *_end_aux_solutions[i];
 
        // We need to synchronize solution so that local_solution has the right values
        _apps[i]->getExecutioner()->feProblem().getAuxiliarySystem().update();
      }
 
      _end_aux_solutions.clear();
    }
 
    // Make sure the displaced mesh on the multiapp is up-to-date with displacement variables
    for (const auto & app_ptr : _apps)
      if (app_ptr->feProblem().getDisplacedProblem())
        app_ptr->feProblem().getDisplacedProblem()->updateMesh();
 
    // If we are restoring due to a failed solve, make sure reset the solved state in the sub-apps
    if (!getMooseApp().getExecutioner()->lastSolveConverged())
      for (auto & app_ptr : _apps)
        app_ptr->getExecutioner()->fixedPointSolve().clearFixedPointStatus();
  }
  else
  {
    for (unsigned int i = 0; i < _my_num_apps; i++)
    {
      for (auto & sub_app :
           _apps[i]->getExecutioner()->feProblem().getMultiAppWarehouse().getObjects())
        sub_app->restore(false);
    }
  }
}

Referenced by dataLoad(), and FullSolveMultiApp::restore().

◆ runningInPosition()

bool MultiApp::runningInPosition ( ) const

inline

Whether or not this MultiApp is being run in position, eg with the coordinate transform already applied.

Definition at line 369 of file MultiApp.h.

369{ return _run_in_position; }

◆ setAppOutputFileBase() [1/2]

void MultiApp::setAppOutputFileBase ( )

Sets all the app's output file bases.

See also: MooseApp::setOutputFileBase for usage

Definition at line 1516 of file MultiApp.C.

{
  for (unsigned int i = 0; i < _my_num_apps; ++i)
    setAppOutputFileBase(i);
}

Referenced by createApp(), and setAppOutputFileBase().

◆ setAppOutputFileBase() [2/2]

void MultiApp::setAppOutputFileBase ( unsigned int index )

protected

Set the output file base of the application which corresponds to the index passed to the function.

Parameters

index The sub-application index

Definition at line 1531 of file MultiApp.C.

{
  const std::string multiapp_name =
      getMultiAppName(name(), _first_local_app + index, _total_num_apps);
  _apps[index]->setOutputFileBase(_app.getOutputFileBase() + "_" + multiapp_name);
}

◆ setupPositions()

void MultiApp::setupPositions ( )

Called just after construction to allow derived classes to set _positions and create sub-apps accordingly.

Definition at line 381 of file MultiApp.C.

{
  if (_use_positions)
  {
    fillPositions();
    init(_positions.size());
    createApps();
  }
}

◆ solveStep()

virtual bool MultiApp::solveStep	(	Real	dt,
		Real	target_time,
		bool	auto_advance = `true`
	)

pure virtual

Re-solve all of the Apps.

Can be called multiple times to resolve the same timestep if auto_advance=false. Time is not actually advanced until advanceStep() is called.

Note that auto_advance=false might not be compatible with the options for the MultiApp

Returns: Whether or not all of the solves were successful (i.e. all solves made it to the target_time)

Implemented in FullSolveMultiApp, and TransientMultiApp.

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

◆ transformBoundingBox()

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

static

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

Definition at line 912 of file MultiApp.C.

{
  const Real min_x = box.first(0);
  const Real max_x = box.second(0);
  const Real min_y = box.first(1);
  const Real max_y = box.second(1);
  const Real min_z = box.first(2);
  const Real max_z = box.second(2);
 
  std::array<Point, 8> box_corners = {{Point(min_x, min_y, min_z),
                                       Point(max_x, min_y, min_z),
                                       Point(min_x, max_y, min_z),
                                       Point(max_x, max_y, min_z),
                                       Point(min_x, min_y, max_z),
                                       Point(max_x, min_y, max_z),
                                       Point(min_x, max_y, max_z),
                                       Point(max_x, max_y, max_z)}};
 
  // transform each corner
  for (auto & corner : box_corners)
    corner = transform(corner);
 
  // Create new bounding box
  Point new_box_min = box_corners[0];
  Point new_box_max = new_box_min;
  for (const auto p : make_range(1, 8))
    for (const auto d : make_range(Moose::dim))
    {
      const Point & pt = box_corners[p];
      if (new_box_min(d) > pt(d))
        new_box_min(d) = pt(d);
 
      if (new_box_max(d) < pt(d))
        new_box_max(d) = pt(d);
    }
  box.first = new_box_min;
  box.second = new_box_max;
}

Referenced by getBoundingBox(), and MultiAppTransfer::transformBoundingBox().

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

◆ usingPositions()

bool MultiApp::usingPositions ( ) const

inline

Whether or not this MultiApp is using positions or its own way for constructing sub-apps.

Definition at line 363 of file MultiApp.h.

363{ return _use_positions; }

Referenced by createApp(), and preTransfer().

◆ validParams()

InputParameters MultiApp::validParams ( )

static

Definition at line 51 of file MultiApp.C.

{
  InputParameters params = MooseObject::validParams();
  params += SetupInterface::validParams();
 
  params.addParam<bool>("use_displaced_mesh",
                        false,
                        "Whether or not this object should use the "
                        "displaced mesh for computation.  Note that "
                        "in the case this is true but no "
                        "displacements are provided in the Mesh block "
                        "the undisplaced mesh will still be used.");
 
  std::ostringstream app_types_strings;
  for (const auto & name_bi_pair : AppFactory::instance().registeredObjects())
    app_types_strings << name_bi_pair.first << " ";
  MooseEnum app_types_options(app_types_strings.str(), "", true);
 
  // Dynamic loading
  params.addParam<MooseEnum>("app_type",
                             app_types_options,
                             "The type of application to build (applications not "
                             "registered can be loaded with dynamic libraries. Parent "
                             "application type will be used if not provided.");
  params.addParam<std::string>("library_path",
                               "",
                               "Path to search for dynamic libraries (please "
                               "avoid committing absolute paths in addition to "
                               "MOOSE_LIBRARY_PATH)");
  params.addParam<std::string>(
      "library_name",
      "",
      "The file name of the library (*.la file) that will be dynamically loaded.");
  params.addParam<bool>("library_load_dependencies",
                        false,
                        "Tells MOOSE to manually load library dependencies. This should not be "
                        "necessary and is here for debugging/troubleshooting.");
 
  // Subapp positions
  params.addParam<std::vector<Point>>(
      "positions",
      "The positions of the App locations.  Each set of 3 values will represent a "
      "Point.  This and 'positions_file' cannot be both supplied. If this and "
      "'positions_file'/'_objects' are not supplied, a single position (0,0,0) will be used");
  params.addParam<std::vector<FileName>>("positions_file",
                                         "Filename(s) that should be looked in for positions. Each"
                                         " set of 3 values in that file will represent a Point.  "
                                         "This and 'positions(_objects)' cannot be both supplied");
  params.addParam<std::vector<PositionsName>>("positions_objects",
                                              "The name of a Positions object that will contain "
                                              "the locations of the sub-apps created. This and "
                                              "'positions(_file)' cannot be both supplied");
  params.addParam<bool>(
      "output_in_position",
      false,
      "If true this will cause the output from the MultiApp to be 'moved' by its position vector");
  params.addParam<bool>(
      "run_in_position",
      false,
      "If true this will cause the mesh from the MultiApp to be 'moved' by its position vector");
 
  params.addRequiredParam<std::vector<FileName>>(
      "input_files",
      "The input file for each App.  If this parameter only contains one input file "
      "it will be used for all of the Apps.  When using 'positions_from_file' it is "
      "also admissable to provide one input_file per file.");
  params.addParam<Real>("bounding_box_inflation",
                        0.01,
                        "Relative amount to 'inflate' the bounding box of this MultiApp.");
  params.addParam<Point>("bounding_box_padding",
                         RealVectorValue(),
                         "Additional padding added to the dimensions of the bounding box. The "
                         "values are added to the x, y and z dimension respectively.");
 
  params.addPrivateParam<MPI_Comm>("_mpi_comm");
 
  // Set the default execution time
  params.set<ExecFlagEnum>("execute_on", true) = EXEC_TIMESTEP_BEGIN;
  // Add the POST_ADAPTIVITY execution flag.
#ifdef LIBMESH_ENABLE_AMR
  ExecFlagEnum & exec_enum = params.set<ExecFlagEnum>("execute_on");
  exec_enum.addAvailableFlags(EXEC_POST_ADAPTIVITY);
  params.setDocString("execute_on", exec_enum.getDocString());
#endif
 
  params.addParam<processor_id_type>("max_procs_per_app",
                                     std::numeric_limits<processor_id_type>::max(),
                                     "Maximum number of processors to give to each App in this "
                                     "MultiApp.  Useful for restricting small solves to just a few "
                                     "procs so they don't get spread out");
  params.addParam<processor_id_type>("min_procs_per_app",
                                     1,
                                     "Minimum number of processors to give to each App in this "
                                     "MultiApp.  Useful for larger, distributed mesh solves.");
  params.addParam<bool>(
      "wait_for_first_app_init",
      false,
      "Create the first sub-application on rank 0, then MPI_Barrier before "
      "creating the next N-1 apps (on all ranks). "
      "This is only needed if your sub-application needs to perform some setup "
      "actions in quiet, without other sub-applications working at the same time.");
 
  params.addParam<Real>("global_time_offset",
                        0,
                        "The time offset relative to the parent application for the purpose of "
                        "starting a subapp at a different time from the parent application. The "
                        "global time will be ahead by the offset specified here.");
 
  // Resetting subapps
  params.addParam<std::vector<Real>>(
      "reset_time",
      {},
      "The time(s) at which to reset Apps given by the 'reset_apps' parameter.  "
      "Resetting an App means that it is destroyed and recreated, possibly "
      "modeling the insertion of 'new' material for that app.");
  params.addParam<std::vector<unsigned int>>(
      "reset_apps",
      {},
      "The Apps that will be reset when 'reset_time' is hit.  These are the App "
      "'numbers' starting with 0 corresponding to the order of the App positions.  "
      "Resetting an App means that it is destroyed and recreated, possibly modeling "
      "the insertion of 'new' material for that app.");
 
  // Moving subapps
  params.addParam<Real>(
      "move_time",
      std::numeric_limits<Real>::max(),
      "The time at which Apps designated by move_apps are moved to move_positions.");
 
  params.addParam<std::vector<unsigned int>>(
      "move_apps",
      {},
      "Apps, designated by their 'numbers' starting with 0 corresponding to the order "
      "of the App positions, to be moved at move_time to move_positions");
  params.addParam<std::vector<Point>>(
      "move_positions", {}, "The positions corresponding to each move_app.");
 
  params.addParam<std::vector<CLIArgString>>(
      "cli_args",
      {},
      "Additional command line arguments to pass to the sub apps. If one set is provided the "
      "arguments are applied to all, otherwise there must be a set for each sub app.");
 
  params.addParam<std::vector<FileName>>(
      "cli_args_files",
      "File names that should be looked in for additional command line arguments "
      "to pass to the sub apps. Each line of a file is set to each sub app. If only "
      "one line is provided, it will be applied to all sub apps.");
 
  // Fixed point iterations
  params.addRangeCheckedParam<Real>("relaxation_factor",
                                    1.0,
                                    "relaxation_factor>0 & relaxation_factor<2",
                                    "Fraction of newly computed value to keep."
                                    "Set between 0 and 2.");
  params.addDeprecatedParam<std::vector<std::string>>(
      "relaxed_variables",
      {},
      "Use transformed_variables.",
      "List of subapp variables to relax during Multiapp coupling iterations");
  params.addParam<std::vector<std::string>>(
      "transformed_variables",
      {},
      "List of subapp variables to use coupling algorithm on during Multiapp coupling iterations");
  params.addParam<std::vector<PostprocessorName>>(
      "transformed_postprocessors",
      {},
      "List of subapp postprocessors to use coupling "
      "algorithm on during Multiapp coupling iterations");
  params.addParam<bool>("keep_solution_during_restore",
                        false,
                        "This is useful when doing MultiApp coupling iterations. It takes the "
                        "final solution from the previous coupling iteration"
                        "and re-uses it as the initial guess for the next coupling iteration");
  params.addParam<bool>("keep_aux_solution_during_restore",
                        false,
                        "This is useful when doing MultiApp coupling iterations. It takes the "
                        "final auxiliary solution from the previous coupling iteration"
                        "and re-uses it as the initial guess for the next coupling iteration");
  params.addParam<bool>(
      "no_restore",
      false,
      "True to turn off restore for this multiapp. This is useful when doing steady-state "
      "Picard iterations where we want to use the solution of previous Picard iteration as the "
      "initial guess of the current Picard iteration.");
  params.addParam<unsigned int>(
      "max_multiapp_level",
      10,
      "Integer set by user that will stop the simulation if the multiapp level "
      "exceeds it. Useful for preventing infinite loops with multiapp simulations");
 
  params.addDeprecatedParam<bool>("clone_master_mesh",
                                  false,
                                  "True to clone parent app mesh and use it for this MultiApp.",
                                  "clone_master_mesh is deprecated, use clone_parent_mesh instead");
  params.addParam<bool>(
      "clone_parent_mesh", false, "True to clone parent app mesh and use it for this MultiApp.");
 
  params.addParam<unsigned int>("execution_order_group",
                                0,
                                "Execution order group. If Problem/num_concurrent_multiapps>1, "
                                "multiple multiapps may be executed synchronously.");
 
  params.addPrivateParam<bool>("use_positions", true);
  params.declareControllable("enable");
  params.declareControllable("cli_args", {EXEC_PRE_MULTIAPP_SETUP});
  params.registerBase("MultiApp");
 
  params.addParamNamesToGroup("use_displaced_mesh wait_for_first_app_init max_multiapp_level",
                              "Advanced");
  params.addParamNamesToGroup("positions positions_file positions_objects run_in_position "
                              "output_in_position",
                              "Positions / transformations of the MultiApp frame of reference");
  params.addParamNamesToGroup("min_procs_per_app max_procs_per_app", "Parallelism");
  params.addParamNamesToGroup("reset_time reset_apps", "Reset MultiApp");
  params.addParamNamesToGroup("move_time move_apps move_positions", "Timed move of MultiApps");
  params.addParamNamesToGroup("relaxation_factor transformed_variables transformed_postprocessors "
                              "keep_solution_during_restore keep_aux_solution_during_restore "
                              "no_restore",
                              "Fixed point iteration");
  params.addParamNamesToGroup("library_name library_path library_load_dependencies",
                              "Dynamic loading");
  params.addParamNamesToGroup("cli_args cli_args_files", "Passing command line argument");
  return params;
}

Referenced by FullSolveMultiApp::validParams(), and TransientMultiApp::validParams().

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

◆ _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(), createApp(), 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(), BoundaryMeshBuilder::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(), 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(), MFEMFileMesh::safeClone(), MFEMMeshGeneratorMesh::safeClone(), 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().

◆ _app_type

std::string MultiApp::_app_type

protected

The type of application to build.

Definition at line 498 of file MultiApp.h.

Referenced by createApp(), and createApps().

◆ _apps

std::vector<std::shared_ptr<MooseApp> > MultiApp::_apps

protected

Pointers to each of the Apps.

Definition at line 554 of file MultiApp.h.

Referenced by appProblem(), appProblemBase(), backup(), createApp(), createApps(), finalize(), getBoundingBox(), getExecutioner(), TransientMultiApp::incrementTStep(), FullSolveMultiApp::initialSetup(), localApp(), moveApp(), numLocalApps(), parentOutputPositionChanged(), postExecute(), preTransfer(), TransientMultiApp::resetApp(), resetApp(), restore(), setAppOutputFileBase(), TransientMultiApp::setupApp(), FullSolveMultiApp::showStatusMessage(), FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ _associated_transfers

std::vector<MultiAppTransfer *> MultiApp::_associated_transfers

protected

Transfers associated with this multiapp.

Definition at line 630 of file MultiApp.h.

Referenced by addAssociatedTransfer(), and preTransfer().

◆ _backup_timer

const PerfID MultiApp::_backup_timer

protected

Definition at line 641 of file MultiApp.h.

Referenced by backup().

◆ _bounding_box

std::vector<libMesh::BoundingBox> MultiApp::_bounding_box

protected

This multi-app's bounding box.

Definition at line 560 of file MultiApp.h.

Referenced by getBoundingBox(), and init().

◆ _bounding_box_padding

Point MultiApp::_bounding_box_padding

protected

Additional padding added to the bounding box, useful for 1D meshes.

Definition at line 566 of file MultiApp.h.

Referenced by getBoundingBox().

◆ _cli_args

const std::vector<CLIArgString>& MultiApp::_cli_args

protected

CommandLine arguments (controllable!)

Definition at line 605 of file MultiApp.h.

Referenced by cliArgs(), and init().

◆ _cli_args_from_file

std::vector<std::string> MultiApp::_cli_args_from_file

protected

CommandLine arguments from files.

Definition at line 608 of file MultiApp.h.

Referenced by createApp(), getCommandLineArgs(), and readCommandLineArguments().

◆ _cli_args_param

std::optional<std::string> MultiApp::_cli_args_param

mutableprivate

The parameter that was used to set the command line args, if any.

Definition at line 647 of file MultiApp.h.

Referenced by cliArgs(), and getCommandLineArgs().

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

const ExecFlagType& SetupInterface::_current_execute_flag

protectedinherited

Reference to FEProblemBase.

Definition at line 86 of file SetupInterface.h.

Referenced by PseudoTimestep::execute().

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

◆ _end_aux_solutions

std::vector<std::unique_ptr<NumericVector<Real> > > MultiApp::_end_aux_solutions

protected

The auxiliary solution from the end of the previous solve, this is cloned from the auxiliary solution during restore.

Definition at line 624 of file MultiApp.h.

Referenced by restore().

◆ _end_solutions

std::vector<std::vector<std::unique_ptr<libMesh::NumericVector<Real> > > > MultiApp::_end_solutions

protected

The solution from the end of the previous solve, this is cloned from the Nonlinear solution during restore Outer indexing by child application, inner indexing by solver system.

Definition at line 621 of file MultiApp.h.

Referenced by restore().

◆ _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(), MFEMTransient::MFEMTransient(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _fe_problem

FEProblemBase& MultiApp::_fe_problem

protected

The FEProblemBase this MultiApp is part of.

Definition at line 495 of file MultiApp.h.

Referenced by backup(), createApp(), fillPositions(), CentroidMultiApp::fillPositions(), QuadraturePointMultiApp::fillPositions(), preTransfer(), problemBase(), restore(), FullSolveMultiApp::showStatusMessage(), and TransientMultiApp::solveStep().

◆ _first_local_app

unsigned int MultiApp::_first_local_app

protected

The number of the first app on this processor.

Definition at line 530 of file MultiApp.h.

Referenced by buildComm(), createApp(), firstLocalApp(), getCommandLineArgs(), globalAppToLocal(), hasLocalApp(), FullSolveMultiApp::initialSetup(), parentOutputPositionChanged(), preTransfer(), setAppOutputFileBase(), TransientMultiApp::setupApp(), FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ _global_time_offset

const Real MultiApp::_global_time_offset

protected

The offset time so the MultiApp local time relative to the global time.

Definition at line 578 of file MultiApp.h.

Referenced by createLocalApp().

◆ _has_an_app

bool MultiApp::_has_an_app

protected

Whether or not this processor as an App at all

Definition at line 602 of file MultiApp.h.

Referenced by appPostprocessorValue(), appProblem(), appProblemBase(), appUserObjectBase(), buildComm(), TransientMultiApp::computeDT(), createApps(), getBoundingBox(), getExecutioner(), hasApp(), hasLocalApp(), FullSolveMultiApp::initialSetup(), TransientMultiApp::initialSetup(), FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ _has_bounding_box

std::vector<bool> MultiApp::_has_bounding_box

protected

Flag if this multi-app computed its bounding box (valid only for non-displaced meshes)

Definition at line 557 of file MultiApp.h.

Referenced by getBoundingBox(), and init().

◆ _inflation

Real MultiApp::_inflation

protected

Relative bounding box inflation.

Definition at line 563 of file MultiApp.h.

Referenced by getBoundingBox().

◆ _init_timer

const PerfID MultiApp::_init_timer

protected

Definition at line 640 of file MultiApp.h.

Referenced by init().

◆ _input_files

std::vector<FileName> MultiApp::_input_files

protected

The input file for each app's simulation.

Definition at line 512 of file MultiApp.h.

Referenced by createApp(), and fillPositions().

◆ _keep_aux_solution_during_restore

bool MultiApp::_keep_aux_solution_during_restore

protected

Flag indicates if or not restart the auxiliary system from the latest auxiliary solution.

Definition at line 614 of file MultiApp.h.

Referenced by restore().

◆ _keep_solution_during_restore

bool MultiApp::_keep_solution_during_restore

protected

Flag indicates if or not restart from the latest solution.

Definition at line 611 of file MultiApp.h.

Referenced by FullSolveMultiApp::FullSolveMultiApp(), FullSolveMultiApp::initialSetup(), keepSolutionDuringRestore(), restore(), and TransientMultiApp::TransientMultiApp().

◆ _max_procs_per_app

processor_id_type MultiApp::_max_procs_per_app

protected

Maximum number of processors to give to each app.

Definition at line 569 of file MultiApp.h.

Referenced by init().

◆ _metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _min_procs_per_app

processor_id_type MultiApp::_min_procs_per_app

protected

Minimum number of processors to give to each app.

Definition at line 572 of file MultiApp.h.

Referenced by init().

◆ _move_apps

std::vector<unsigned int> MultiApp::_move_apps

protected

The apps to be moved.

Definition at line 593 of file MultiApp.h.

Referenced by fillPositions(), and preTransfer().

◆ _move_happened

bool MultiApp::_move_happened

protected

Whether or not the move has happened.

Definition at line 599 of file MultiApp.h.

Referenced by preTransfer().

◆ _move_positions

std::vector<Point> MultiApp::_move_positions

protected

The new positions for the apps to be moved.

Definition at line 596 of file MultiApp.h.

Referenced by fillPositions(), and preTransfer().

◆ _move_time

Real MultiApp::_move_time

protected

The time at which to move apps.

Definition at line 590 of file MultiApp.h.

Referenced by preTransfer().

◆ _my_comm

MPI_Comm& MultiApp::_my_comm

protected

The MPI communicator this object is going to use.

Definition at line 539 of file MultiApp.h.

Referenced by buildComm(), comm(), TransientMultiApp::computeDT(), createApp(), createApps(), getBoundingBox(), FullSolveMultiApp::initialSetup(), TransientMultiApp::initialSetup(), TransientMultiApp::resetApp(), resetApp(), FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ _my_communicator

libMesh::Parallel::Communicator MultiApp::_my_communicator

protected

The communicator object that holds the MPI_Comm that we're going to use.

Definition at line 536 of file MultiApp.h.

Referenced by buildComm().

◆ _my_num_apps

unsigned int MultiApp::_my_num_apps

protected

The number of apps this object is involved in simulating.

Definition at line 527 of file MultiApp.h.

Referenced by backup(), buildComm(), TransientMultiApp::computeDT(), createApps(), TransientMultiApp::finishStep(), globalAppToLocal(), hasLocalApp(), TransientMultiApp::incrementTStep(), init(), FullSolveMultiApp::initialSetup(), TransientMultiApp::initialSetup(), preTransfer(), restore(), setAppOutputFileBase(), FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ _my_rank

int MultiApp::_my_rank

protected

The mpi "rank" of this processor in the sub communicator.

Definition at line 551 of file MultiApp.h.

Referenced by buildComm(), and isRootProcessor().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _no_restore

const bool MultiApp::_no_restore

protected

Whether or not to skip restoring completely.

Definition at line 617 of file MultiApp.h.

Referenced by FullSolveMultiApp::FullSolveMultiApp(), needsRestoration(), and FullSolveMultiApp::restore().

◆ _node_name

std::string MultiApp::_node_name

protected

Node Name.

Definition at line 548 of file MultiApp.h.

Referenced by buildComm().

◆ _npositions_inputfile

std::vector<unsigned int> MultiApp::_npositions_inputfile

protected

Number of positions for each input file.

Definition at line 518 of file MultiApp.h.

Referenced by fillPositions(), and readCommandLineArguments().

◆ _orig_comm

const MPI_Comm& MultiApp::_orig_comm

protected

The original comm handle.

Definition at line 533 of file MultiApp.h.

Referenced by createApps().

◆ _orig_num_procs

int MultiApp::_orig_num_procs

protected

The number of processors in the original comm.

Definition at line 542 of file MultiApp.h.

Referenced by buildComm().

◆ _orig_rank

int MultiApp::_orig_rank

protected

The mpi "rank" of this processor in the original communicator.

Definition at line 545 of file MultiApp.h.

Referenced by appPostprocessorValue(), appProblem(), appProblemBase(), appUserObjectBase(), buildComm(), getBoundingBox(), and getExecutioner().

◆ _output_base

std::string MultiApp::_output_base

protected

The output file basename for each multiapp.

Definition at line 521 of file MultiApp.h.

◆ _output_in_position

bool MultiApp::_output_in_position

protected

Whether or not to move the output of the MultiApp into position.

Definition at line 575 of file MultiApp.h.

Referenced by createApp(), moveApp(), and parentOutputPositionChanged().

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

◆ _positions

std::vector<Point> MultiApp::_positions

protected

The positions of all of the apps, using input constant vectors (to be deprecated)

Definition at line 501 of file MultiApp.h.

Referenced by createApp(), fillPositions(), CentroidMultiApp::fillPositions(), QuadraturePointMultiApp::fillPositions(), moveApp(), parentOutputPositionChanged(), position(), preTransfer(), and setupPositions().

◆ _positions_index_offsets

std::vector<unsigned int> MultiApp::_positions_index_offsets

protected

The offsets, in case multiple Positions objects are specified.

Definition at line 505 of file MultiApp.h.

Referenced by fillPositions(), and position().

◆ _positions_objs

std::vector<const Positions *> MultiApp::_positions_objs

protected

The positions of all of the apps, using the Positions system.

Definition at line 503 of file MultiApp.h.

Referenced by fillPositions(), and position().

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

◆ _rank_config

LocalRankConfig MultiApp::_rank_config

protected

The app configuration resulting from calling init.

Definition at line 627 of file MultiApp.h.

Referenced by buildComm(), init(), and isFirstLocalRank().

◆ _reset_apps

std::vector<unsigned int> MultiApp::_reset_apps

protected

The apps to be reset.

Definition at line 584 of file MultiApp.h.

Referenced by MultiApp(), and preTransfer().

◆ _reset_happened

std::vector<bool> MultiApp::_reset_happened

protected

Whether or not apps have been reset at each time.

Definition at line 587 of file MultiApp.h.

Referenced by init(), preTransfer(), and TransientMultiApp::solveStep().

◆ _reset_timer

const PerfID MultiApp::_reset_timer

protected

Definition at line 643 of file MultiApp.h.

Referenced by resetApp().

◆ _reset_times

std::vector<Real> MultiApp::_reset_times

protected

The times at which to reset apps.

Definition at line 581 of file MultiApp.h.

Referenced by init(), MultiApp(), and preTransfer().

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

◆ _restore_timer

const PerfID MultiApp::_restore_timer

protected

Definition at line 642 of file MultiApp.h.

Referenced by restore().

◆ _run_in_position

const bool MultiApp::_run_in_position

protected

Whether to run the child apps with their meshes transformed with the coordinate transforms.

Definition at line 633 of file MultiApp.h.

Referenced by createApp(), moveApp(), preTransfer(), and runningInPosition().

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

◆ _solve_step_timer

const PerfID MultiApp::_solve_step_timer

protected

Timers.

Definition at line 639 of file MultiApp.h.

Referenced by FullSolveMultiApp::solveStep(), and TransientMultiApp::solveStep().

◆ _sub_app_backups

SubAppBackups& MultiApp::_sub_app_backups

protected

The cached subapp backups (passed from the parent app)

Definition at line 636 of file MultiApp.h.

Referenced by backup(), createApp(), init(), and restore().

◆ _total_num_apps

unsigned int MultiApp::_total_num_apps

protected

The total number of apps to simulate.

Definition at line 524 of file MultiApp.h.

Referenced by buildComm(), createApp(), init(), numGlobalApps(), readCommandLineArguments(), and setAppOutputFileBase().

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

const bool MultiApp::_use_positions

protected

Toggle use of "positions".

Subapps are created at each different position. List of positions can be created using the Positions system

Definition at line 509 of file MultiApp.h.

Referenced by createApp(), initialSetup(), moveApp(), MultiApp(), parentOutputPositionChanged(), preTransfer(), setupPositions(), and usingPositions().

◆ _wait_for_first_app_init

const bool& MultiApp::_wait_for_first_app_init

protected

Whether to create the first app on rank 0 while all other MPI ranks are idle.

Definition at line 515 of file MultiApp.h.

Referenced by createApps().

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

◆ 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/multiapps/MultiApp.h
src/multiapps/MultiApp.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ MultiApp()

Member Function Documentation

◆ addAssociatedTransfer()

◆ appPostprocessorValue()

◆ appProblem()

◆ appProblemBase()

◆ appTransferVector()

◆ appUserObjectBase()

◆ backup()

◆ buildComm()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ cliArgs()

◆ comm()

◆ connectControllableParams()

◆ createApp()

◆ createApps()

◆ createLocalApp()

◆ customSetup()

◆ declareManagedRestartableDataWithContext()

◆ declareRecoverableData()

◆ declareRestartableData()

◆ declareRestartableDataHelper()

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ enabled()

◆ errorPrefix()

◆ fillPositions()

◆ finalize()

◆ finishStep()

◆ firstLocalApp()

◆ flagInvalidSolutionInternal()

◆ getBase()

◆ getBoundingBox()

◆ getCheckedPointerParam()

◆ getCommandLineArgs()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getExecuteOnEnum()

◆ getExecutioner()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getMooseApp()

◆ getMultiAppName()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getRenamedParam()

◆ getRestartableData()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ globalAppToLocal()

◆ hasApp()

◆ hasBase()

◆ hasLocalApp()

◆ incrementTStep()

◆ init() [1/2]

◆ init() [2/2]

◆ initialSetup()

◆ isFirstLocalRank()

◆ isKokkosObject()

◆ isParamSetByUser()

◆ isParamValid()

◆ isRootProcessor()