Automatically generates sub-App positions with elemental quadrature points of the parent mesh. More...

#include <QuadraturePointMultiApp.h>

Inheritance diagram for QuadraturePointMultiApp:

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

Public Member Functions
	QuadraturePointMultiApp (const InputParameters &parameters)

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

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

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

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

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

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

Real	computeDT ()
	Finds the smallest dt from among any of the apps. More...

virtual void	preExecute ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const Parallel::Communicator &	comm () const

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

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

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

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

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

virtual bool	enabled () const
	Return the enabled status of the object. More...

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group. More...

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

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with. More...

const std::string &	type () const
	Get the type of this class. More...

virtual const std::string &	name () const
	Get the name of the class. More...

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...

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

void	callMooseError (std::string msg, const bool with_prefix) const
	Calls moose error with the message `msg`. More...

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

const InputParameters &	parameters () const
	Get the parameters of the object. More...

MooseObjectName	uniqueName () const
	The unique name for accessing input parameters of this object in the InputParameterWarehouse. More...

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object. More...

template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object. More...

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...

bool	isParamSetByUser (const std::string &nm) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type. More...

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError(). More...

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
	Emits a documented error with object name and type. More...

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...

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

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

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method. More...

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...

virtual void	timestepSetup ()
	Gets called at the beginning of the timestep before this object is asked to do its job. More...

virtual void	jacobianSetup ()
	Gets called just before the Jacobian is computed and before this object is asked to do its job. More...

virtual void	residualSetup ()
	Gets called just before the residual is computed and before this object is asked to do its job. More...

virtual void	subdomainSetup ()
	Gets called when the subdomain changes (i.e. More...

virtual void	customSetup (const ExecFlagType &)
	Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain. More...

const ExecFlagEnum &	getExecuteOnEnum () const
	Return the execute on MultiMooseEnum for this object. More...

PerfGraph &	perfGraph ()
	Get the PerfGraph. More...

const std::vector< SubdomainName > &	blocks () const
	Return the block names for this object. More...

unsigned int	numBlocks () const
	Return the number of blocks for this object. More...

virtual const std::set< SubdomainID > &	blockIDs () const
	Return the block subdomain ids for this object Note, if this is not block restricted, this function returns all mesh subdomain ids. More...

unsigned int	blocksMaxDimension () const
	Return the largest mesh dimension of the elements in the blocks for this object. More...

bool	hasBlocks (const SubdomainName &name) const
	Test if the supplied block name is valid for this object. More...

bool	hasBlocks (const std::vector< SubdomainName > &names) const
	Test if the supplied vector of block names are valid for this object. More...

bool	hasBlocks (const std::set< SubdomainName > &names) const
	Test if the supplied set of block names are valid for this object. More...

bool	hasBlocks (SubdomainID id) const
	Test if the supplied block ids are valid for this object. More...

bool	hasBlocks (const std::vector< SubdomainID > &ids) const
	Test if the supplied vector block ids are valid for this object. More...

bool	hasBlocks (const std::set< SubdomainID > &ids) const
	Test if the supplied set of block ids are valid for this object. More...

bool	isBlockSubset (const std::set< SubdomainID > &ids) const
	Test if the class block ids are a subset of the supplied objects. More...

bool	isBlockSubset (const std::vector< SubdomainID > &ids) const
	Test if the class block ids are a subset of the supplied objects. More...

template<typename T , bool is_ad = false>
bool	hasBlockMaterialProperty (const std::string &prop_name)
	Check if a material property is valid for all blocks of this object. More...

const std::set< SubdomainID > &	meshBlockIDs () const
	Return all of the SubdomainIDs for the mesh. More...

virtual bool	blockRestricted () const
	Returns true if this object has been restricted to a block. More...

virtual void	checkVariable (const MooseVariableFieldBase &variable) const
	Helper for checking that the ids for this object are in agreement with the variables on the supplied variable. More...

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

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

Protected Member Functions
void	fillPositions () override
	must fill in _positions with the positions of the sub-aps More...

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

virtual std::vector< std::string >	cliArgs () const
	function that provides cli_args to subapps More...

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

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

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

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

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

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

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

void	createApps ()
	Create the provided number of apps. More...

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

template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...

template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to `declareRestartableData` but returns a const reference to the object. More...

template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...

std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing. More...

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing. More...

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

virtual bool	hasBlockMaterialPropertyHelper (const std::string &prop_name)
	A helper method to allow the Material object to specialize the behavior of hasBlockMaterialProperty. More...

void	initializeBlockRestrictable (const MooseObject *moose_object)
	An initialization routine needed for dual constructors. More...

Moose::CoordinateSystemType	getBlockCoordSystem ()
	Check if the blocks this object operates on all have the same coordinate system, and if so return it. More...

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

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

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

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

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

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

const bool	_use_positions
	Toggle use of "positions". More...

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

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

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

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

unsigned int	_total_num_apps
	The total number of apps to simulate. More...

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

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

const MPI_Comm &	_orig_comm
	The original comm handle. More...

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

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

int	_orig_num_procs
	The number of processors in the original comm. More...

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

std::string	_node_name
	Node Name. More...

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

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

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

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

Real	_inflation
	Relative bounding box inflation. More...

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

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

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

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

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

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

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

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

Real	_move_time
	The time at which to move apps. More...

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

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

bool	_move_happened
	Whether or not the move has happened. More...

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

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

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

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

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

const bool	_no_restore
	Whether or not to skip restoring completely. More...

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

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

LocalRankConfig	_rank_config
	The app configuration resulting from calling init. More...

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

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

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

const PerfID	_solve_step_timer
	Timers. More...

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

MooseApp &	_app
	The MOOSE application this is associated with. More...

const std::string	_type
	The type of this class. More...

const std::string	_name
	The name of this class. More...

const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...

Factory &	_factory
	The Factory associated with the MooseApp. More...

ActionFactory &	_action_factory
	Builds Actions. More...

const Parallel::Communicator &	_communicator

const ExecFlagEnum &	_execute_enum
	Execute settings for this object. More...

const ExecFlagType &	_current_execute_flag
	Reference to FEProblemBase. More...

MooseApp &	_restartable_app
	Reference to the application. More...

const std::string	_restartable_system_name
	The system name this object is in. More...

const THREAD_ID	_restartable_tid
	The thread ID for this object. More...

const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...

const std::string	_prefix
	A prefix to use for all sections. More...

const MaterialData *	_blk_material_data
	Pointer to the MaterialData class for this object. More...

Detailed Description

Automatically generates sub-App positions with elemental quadrature points of the parent mesh.

Definition at line 18 of file QuadraturePointMultiApp.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

◆ QuadraturePointMultiApp()

QuadraturePointMultiApp::QuadraturePointMultiApp ( const InputParameters & parameters )

Definition at line 40 of file QuadraturePointMultiApp.C.

   : TransientMultiApp(parameters), BlockRestrictable(this)
 {
 }

Member Function Documentation

◆ addAssociatedTransfer()

void MultiApp::addAssociatedTransfer ( MultiAppTransfer & transfer )

inherited

Add a transfer that is associated with this multiapp.

Definition at line 1475 of file MultiApp.C.

 {
   _associated_transfers.push_back(&transfer);
 }

◆ appPostprocessorValue()

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

inherited

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 1050 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 )

inherited

Get the FEProblem for the global app is part of.

Parameters

app	The global app number

Definition at line 1028 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 )

inherited

Get the FEProblemBase for the global app desired.

Parameters

app	The global app number

Definition at line 1017 of file MultiApp.C.

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

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

◆ appTransferVector()

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

overridevirtualinherited

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

Definition at line 142 of file TransientMultiApp.C.

 {
   if (std::find(_transferred_vars.begin(), _transferred_vars.end(), var_name) ==
       _transferred_vars.end())
     _transferred_vars.push_back(var_name);
 
   if (_interpolate_transfers)
     return appProblemBase(app).getAuxiliarySystem().system().get_vector("transfer");
 
   return appProblemBase(app).getAuxiliarySystem().solution();
 }

◆ appUserObjectBase()

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

inherited

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

virtualinherited

Save off the state of every Sub App.

This allows us to "Restore" this state later

Definition at line 760 of file MultiApp.C.

Referenced by dataStore(), and MultiApp::preTransfer().

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

◆ blockIDs()

const std::set< SubdomainID > & BlockRestrictable::blockIDs ( ) const

virtualinherited

Return the block subdomain ids for this object Note, if this is not block restricted, this function returns all mesh subdomain ids.

Returns: a set of SubdomainIDs that are valid for this object

Definition at line 194 of file BlockRestrictable.C.

Referenced by FunctorMaterial::addFunctorProperty(), DiracKernelBase::addPoint(), DiracKernelBase::addPointWithValidId(), NodalPatchRecoveryAuxBase::blockRestrictElements(), ComboMarker::ComboMarker(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), BlockRestrictable::getBlockCoordSystem(), MaterialBase::getGenericZeroMaterialPropertyByName(), FunctorIC::gradient(), BlockRestrictable::hasBlockMaterialPropertyHelper(), IndicatorMarker::IndicatorMarker(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), QuadraturePointsPositions::initialize(), FunctorExtremaPositions::initialize(), MooseVariableBase::MooseVariableBase(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), MaterialBase::registerPropName(), FVPointValueConstraint::setMyElem(), and FunctorIC::value().

 {
   if (_blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return _blk_mesh->meshSubdomains();
   else
     return _blk_ids;
 }

◆ blockRestricted()

bool BlockRestrictable::blockRestricted ( ) const

virtualinherited

Returns true if this object has been restricted to a block.

See also: MooseObject

Definition at line 182 of file BlockRestrictable.C.

Referenced by NodalPatchRecoveryAuxBase::blockRestrictElements(), BlockRestrictable::checkVariable(), SubdomainsDivision::divisionIndex(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), BlockRestrictable::getBlockCoordSystem(), FunctorIC::gradient(), BlockRestrictable::hasBlockMaterialPropertyHelper(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), QuadraturePointsPositions::initialize(), BlockRestrictable::initializeBlockRestrictable(), SolutionIC::initialSetup(), MooseVariableBase::MooseVariableBase(), FVPointValueConstraint::setMyElem(), and FunctorIC::value().

 {
   return _blk_ids.find(Moose::ANY_BLOCK_ID) == _blk_ids.end();
 }

◆ blocks()

const std::vector< SubdomainName > & BlockRestrictable::blocks ( ) const

inherited

Return the block names for this object.

Note, if the 'blocks' input parameter was not utilized this will return an empty vector.

Returns: vector of SubdomainNames that are valid for this object

Definition at line 188 of file BlockRestrictable.C.

Referenced by MaterialOutputAction::getParams(), SubdomainsDivision::initialize(), and SolutionIC::initialSetup().

 {
   return _blocks;
 }

◆ blocksMaxDimension()

unsigned int BlockRestrictable::blocksMaxDimension ( ) const

inherited

Return the largest mesh dimension of the elements in the blocks for this object.

Definition at line 371 of file BlockRestrictable.C.

 {
   mooseAssert(_blk_dim != libMesh::invalid_uint, "Block restriction not initialized");
   return _blk_dim;
 }

◆ buildComm()

void MultiApp::buildComm ( )

protectedinherited

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 1409 of file MultiApp.C.

Referenced by MultiApp::init().

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

◆ callMooseError()

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

inherited

Calls moose error with the message msg.

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

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

Definition at line 33 of file MooseBase.C.

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

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

◆ checkVariable()

void BlockRestrictable::checkVariable ( const MooseVariableFieldBase & variable ) const

virtualinherited

Helper for checking that the ids for this object are in agreement with the variables on the supplied variable.

Parameters

variable The variable to check against.

Reimplemented in DomainUserObject.

Definition at line 343 of file BlockRestrictable.C.

Referenced by DomainUserObject::checkVariable().

 {
   // a variable defined on all internal sides does not need this check because
   // it can be coupled with other variables in DG kernels
   if (!_blk_mesh->interiorLowerDBlocks().empty() &&
       variable.activeOnSubdomains(_blk_mesh->interiorLowerDBlocks()))
     return;
 
   if (!isBlockSubset(variable.activeSubdomains()))
   {
     std::string var_ids = Moose::stringify(variable.activeSubdomains(), ", ");
     std::string obj_ids = Moose::stringify(blockRestricted() ? _blk_ids : meshBlockIDs(), ", ");
     mooseError("The 'block' parameter of the object '",
                _blk_name,
                "' must be a subset of the 'block' parameter of the variable '",
                variable.name(),
                "':\n    Object '",
                _blk_name,
                "': ",
                obj_ids,
                "\n    Variable '",
                variable.name(),
                "': ",
                var_ids);
   }
 }

◆ cliArgs()

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

protectedvirtualinherited

function that provides cli_args to subapps

Definition at line 1488 of file MultiApp.C.

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

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

◆ comm()

MPI_Comm& MultiApp::comm ( )

inlineinherited

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

MultiApp::_my_comm

MPI_Comm & _my_comm

The MPI communicator this object is going to use.

Definition: MultiApp.h:526

◆ computeDT()

Real TransientMultiApp::computeDT ( )

inherited

Finds the smallest dt from among any of the apps.

Definition at line 589 of file TransientMultiApp.C.

 {
   if (_sub_cycling) // Bow out of the timestep selection dance
     return std::numeric_limits<Real>::max();
 
   Real smallest_dt = std::numeric_limits<Real>::max();
 
   if (_has_an_app)
   {
     Moose::ScopedCommSwapper swapper(_my_comm);
 
     for (unsigned int i = 0; i < _my_num_apps; i++)
     {
       TransientBase * ex = _transient_executioners[i];
       ex->computeDT();
       Real dt = ex->getDT();
 
       smallest_dt = std::min(dt, smallest_dt);
     }
   }
 
   if (_tolerate_failure) // Bow out of the timestep selection dance, we do this down here because we
                          // need to call computeConstrainedDT at least once for these
                          // executioners...
     return std::numeric_limits<Real>::max();
 
   _communicator.min(smallest_dt);
   return smallest_dt;
 }

◆ connectControllableParams()

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

inherited

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

Parameters

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

Definition at line 33 of file MooseBaseParameterInterface.C.

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

◆ createApp()

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

protectedinherited

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 1136 of file MultiApp.C.

Referenced by MultiApp::createLocalApp(), and MultiApp::resetApp().

 {
   // 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);
   // 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);
   app_cli->parse();
   app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(app_cli);
 
   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
   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::vector<std::string>>("_mfem_devices") =
       std::vector<std::string>(mfem_device_set.begin(), mfem_device_set.end());
 #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);
 
   if (input_file.size())
   {
     parser->parse();
     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);
   _apps[i] = AppFactory::instance().createShared(_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(_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)
   {
     if (usingPositions())
       app->getExecutioner()->feProblem().coordTransform().transformMesh(
           app->getExecutioner()->feProblem().mesh(), _positions[_first_local_app + i]);
     else
       app->getExecutioner()->feProblem().coordTransform().transformMesh(
           app->getExecutioner()->feProblem().mesh(), Point(0, 0, 0));
   }
 }

◆ createApps()

void MultiApp::createApps ( )

protectedinherited

Create the provided number of apps.

This is called in the setupPositions().

Definition at line 388 of file MultiApp.C.

Referenced by MultiApp::initialSetup(), and MultiApp::setupPositions().

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

◆ createLocalApp()

void MultiApp::createLocalApp ( const unsigned int i )

virtualinherited

Create the i-th local app.

Parameters

[in] i local app index

Definition at line 432 of file MultiApp.C.

Referenced by MultiApp::createApps().

 {
   createApp(i, _global_time_offset);
 }

◆ customSetup()

virtual void SetupInterface::customSetup ( const ExecFlagType & )

inlinevirtualinherited

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

Reimplemented in Function.

Definition at line 61 of file SetupInterface.h.

61 {}

◆ declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 276 of file Restartable.h.

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

◆ declareRecoverableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

Note - this data will NOT be restored on Restart!

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

Parameters

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

Definition at line 351 of file Restartable.h.

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

◆ declareRestartableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 269 of file Restartable.h.

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

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 294 of file Restartable.h.

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

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 323 of file Restartable.h.

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

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 333 of file Restartable.h.

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

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 40 of file MooseObject.h.

Referenced by EigenKernel::enabled().

40 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition: MooseObject.h:51

◆ errorPrefix()

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

inherited

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

Definition at line 43 of file MooseBase.C.

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

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

◆ fillPositions()

void QuadraturePointMultiApp::fillPositions ( )

overrideprotectedvirtual

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

Reimplemented from MultiApp.

Definition at line 46 of file QuadraturePointMultiApp.C.

 {
   MooseMesh & main_mesh = _fe_problem.mesh();
   auto & mesh = main_mesh.getMesh();
   for (auto & elem : mesh.active_local_element_ptr_range())
   {
     // FEType is local to the element, supporting mixed order meshes
     const FEFamily mapping_family = FEMap::map_fe_type(*elem);
     FEType fe_type(elem->default_order(), mapping_family);
     const auto qrule = fe_type.default_quadrature_rule(elem->dim());
 
     // Build a Finite Element object of the specified type
     std::unique_ptr<FEBase> fe(FEBase::build(elem->dim(), fe_type));
 
     // Tell the finite element object to use our quadrature rule.
     fe->attach_quadrature_rule(qrule.get());
 
     // The physical XY locations of the quadrature points on the element.
     // These might be useful for evaluating spatially varying material
     // properties at the quadrature points.
     const std::vector<Point> & q_points = fe->get_xyz();
     fe->reinit(elem);
 
     if (hasBlocks(elem->subdomain_id()))
       for (const auto & q : q_points)
         _positions.push_back(q);
   }
 
   // Remove local duplicates from the vector of positions as transfers will not handle them
   std::sort(_positions.begin(), _positions.end());
   _positions.erase(std::unique(_positions.begin(), _positions.end()), _positions.end());
 
   // Use the comm from the problem this MultiApp is part of
   libMesh::ParallelObject::comm().allgather(_positions);
 
   // Remove duplicates occurring at process boundaries
   std::sort(_positions.begin(), _positions.end());
   _positions.erase(std::unique(_positions.begin(), _positions.end()), _positions.end());
 
   if (_positions.empty())
     mooseError("No positions found for QuadraturePointMultiApp ", _name);
 }

◆ finalize()

void MultiApp::finalize ( )

virtualinherited

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

Reimplemented in FullSolveMultiApp.

Definition at line 735 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()

void TransientMultiApp::finishStep ( bool = false )

overridevirtualinherited

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

Definition at line 568 of file TransientMultiApp.C.

 {
   if (!_sub_cycling)
   {
     for (unsigned int i = 0; i < _my_num_apps; i++)
     {
       TransientBase * ex = _transient_executioners[i];
       ex->endStep();
       ex->postStep();
       if (recurse_through_multiapp_levels)
       {
         ex->feProblem().finishMultiAppStep(EXEC_TIMESTEP_BEGIN,
                                            /*recurse_through_multiapp_levels=*/true);
         ex->feProblem().finishMultiAppStep(EXEC_TIMESTEP_END,
                                            /*recurse_through_multiapp_levels=*/true);
       }
     }
   }
 }

◆ firstLocalApp()

unsigned int MultiApp::firstLocalApp ( )

inlineinherited

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

MultiApp::_first_local_app

unsigned int _first_local_app

The number of the first app on this processor.

Definition: MultiApp.h:517

◆ getBlockCoordSystem()

Moose::CoordinateSystemType BlockRestrictable::getBlockCoordSystem ( )

protectedinherited

Check if the blocks this object operates on all have the same coordinate system, and if so return it.

Definition at line 321 of file BlockRestrictable.C.

 {
   if (!_blk_mesh)
     mooseError("No mesh available in BlockRestrictable::checkCoordSystem()");
   if (!_blk_feproblem)
     mooseError("No problem available in BlockRestrictable::checkCoordSystem()");
 
   const auto & subdomains = blockRestricted() ? blockIDs() : meshBlockIDs();
 
   if (subdomains.empty())
     mooseError("No subdomains found in the problem.");
 
   // make sure all subdomains are using the same coordinate system
   auto coord_system = _blk_feproblem->getCoordSystem(*subdomains.begin());
   for (auto subdomain : subdomains)
     if (_blk_feproblem->getCoordSystem(subdomain) != coord_system)
       mooseError("This object requires all subdomains to have the same coordinate system.");
 
   return coord_system;
 }

◆ getBoundingBox()

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

virtualinherited

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 943 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 MooseBaseParameterInterface::getCheckedPointerParam	(	const std::string &	name,
		const std::string &	error_string = `""`
	)		const

inherited

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

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

Definition at line 286 of file MooseBaseParameterInterface.h.

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

◆ getCommandLineArgs()

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

protectedvirtualinherited

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 1278 of file MultiApp.C.

Referenced by MultiApp::createApp().

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

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

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

◆ getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const

inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 66 of file SetupInterface.C.

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

 {
   return _execute_enum;
 }

◆ getExecutioner()

Executioner * MultiApp::getExecutioner ( unsigned int app )

virtualinherited

Parameters

app	The global app number to get the Executioner for

Returns: The Executioner associated with that App.

Definition at line 726 of file MultiApp.C.

Referenced by MultiApp::restore().

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

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

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

45 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:84

◆ getMultiAppName()

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

staticprotectedinherited

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 1504 of file MultiApp.C.

Referenced by MultiApp::createApp(), and MultiApp::setAppOutputFileBase().

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

◆ getParam() [1/2]

template<typename T >

const T & MooseBaseParameterInterface::getParam ( const std::string & name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 215 of file MooseBaseParameterInterface.h.

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

Definition at line 279 of file MooseBaseParameterInterface.h.

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

◆ getRenamedParam()

template<typename T >

const T & MooseBaseParameterInterface::getRenamedParam	(	const std::string &	old_name,
		const std::string &	new_name
	)		const

inherited

Retrieve a renamed parameter for the object.

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

Parameters

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

Definition at line 229 of file MooseBaseParameterInterface.h.

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

◆ getRestartableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 287 of file Restartable.h.

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

◆ getSharedPtr() [1/2]

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

inherited

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

Wrapper around shared_from_this().

Definition at line 68 of file MooseObject.C.

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

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 81 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 )

protectedinherited

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 1451 of file MultiApp.C.

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

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

◆ hasApp()

bool MultiApp::hasApp ( )

inlineinherited

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

Definition at line 298 of file MultiApp.h.

298 { return _has_an_app; }

MultiApp::_has_an_app

bool _has_an_app

Whether or not this processor as an App at all

Definition: MultiApp.h:589

◆ hasBlockMaterialProperty()

template<typename T , bool is_ad>

bool BlockRestrictable::hasBlockMaterialProperty ( const std::string & prop_name )

inherited

Check if a material property is valid for all blocks of this object.

This method returns true if the supplied property name has been declared in a Material object on the block ids for this object.

Template Parameters

T	The type of material property

Parameters

prop_name the name of the property to query

Returns: true if the property exists for all block ids of the object, otherwise false

See also: Material::hasBlockMaterialProperty

Definition at line 271 of file BlockRestrictable.h.

 {
   mooseAssert(_blk_material_data != NULL, "MaterialData pointer is not defined");
   return hasBlockMaterialPropertyHelper(prop_name) &&
          _blk_material_data->haveGenericProperty<T, is_ad>(prop_name);
 }

◆ hasBlockMaterialPropertyHelper()

bool BlockRestrictable::hasBlockMaterialPropertyHelper ( const std::string & prop_name )

protectedvirtualinherited

A helper method to allow the Material object to specialize the behavior of hasBlockMaterialProperty.

It also avoid circular #include problems.

See also: hasBlockMaterialProperty

Definition at line 285 of file BlockRestrictable.C.

Referenced by BlockRestrictable::hasBlockMaterialProperty().

 {
 
   // Reference to MaterialWarehouse for testing and retrieving block ids
   const MaterialWarehouse & warehouse = _blk_feproblem->getMaterialWarehouse();
 
   // Complete set of ids that this object is active
   const std::set<SubdomainID> & ids = blockRestricted() ? blockIDs() : meshBlockIDs();
 
   // Loop over each id for this object
   for (const auto & id : ids)
   {
     // Storage of material properties that have been DECLARED on this id
     std::set<std::string> declared_props;
 
     // If block materials exist, populated the set of properties that were declared
     if (warehouse.hasActiveBlockObjects(id))
     {
       const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(id);
       for (const auto & mat : mats)
       {
         const std::set<std::string> & mat_props = mat->getSuppliedItems();
         declared_props.insert(mat_props.begin(), mat_props.end());
       }
     }
 
     // If the supplied property is not in the list of properties on the current id, return false
     if (declared_props.find(prop_name) == declared_props.end())
       return false;
   }
 
   // If you get here the supplied property is defined on all blocks
   return true;
 }

◆ hasBlocks() [1/6]

bool BlockRestrictable::hasBlocks ( const SubdomainName & name ) const

inherited

Test if the supplied block name is valid for this object.

Parameters

name	A SubdomainName to check

Returns: True if the given id is valid for this object

Definition at line 209 of file BlockRestrictable.C.

Referenced by LinearFVFluxKernel::addMatrixContribution(), DiracKernelBase::addPoint(), LinearFVFluxKernel::addRightHandSideContribution(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), DomainUserObject::checkVariable(), ComputeJacobianThread::compute(), ComboMarker::computeElementMarker(), GradientJumpIndicator::computeQpIntegral(), ProjectionAux::computeValue(), DomainUserObject::DomainUserObject(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), fillPositions(), CentroidMultiApp::fillPositions(), MeshDivisionFunctorReductionVectorPostprocessor::hasBlocks(), BlockRestrictable::hasBlocks(), MooseVariableField< Real >::hasBlocks(), FVFluxKernel::hasFaceSide(), IndicatorMarker::IndicatorMarker(), NodePositions::initialize(), ParsedDownSelectionPositions::initialize(), UpdateErrorVectorsThread::onElement(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), and BlockRestrictionDebugOutput::printBlockRestrictionMap().

 {
   // Create a vector and utilize the getSubdomainIDs function, which
   // handles the ANY_BLOCK_ID (getSubdomainID does not)
   std::vector<SubdomainName> names(1);
   names[0] = name;
   return hasBlocks(_blk_mesh->getSubdomainIDs(names));
 }

◆ hasBlocks() [2/6]

bool BlockRestrictable::hasBlocks ( const std::vector< SubdomainName > & names ) const

inherited

Test if the supplied vector of block names are valid for this object.

Parameters

names A vector of SubdomainNames to check

Returns: True if the given ids are valid for this object

Definition at line 219 of file BlockRestrictable.C.

 {
   return hasBlocks(_blk_mesh->getSubdomainIDs(names));
 }

◆ hasBlocks() [3/6]

bool BlockRestrictable::hasBlocks ( const std::set< SubdomainName > & names ) const

inherited

Test if the supplied set of block names are valid for this object.

Parameters

names A set of SubdomainNames to check

Returns: True if the given ids are valid for this object

Definition at line 225 of file BlockRestrictable.C.

 {
   return hasBlocks(_blk_mesh->getSubdomainIDs(names));
 }

◆ hasBlocks() [4/6]

bool BlockRestrictable::hasBlocks ( SubdomainID id ) const

inherited

Test if the supplied block ids are valid for this object.

Parameters

id	A SubdomainID to check

Returns: True if the given id is valid for this object

Definition at line 231 of file BlockRestrictable.C.

 {
   if (_blk_ids.empty() || _blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return true;
   else
     return _blk_ids.find(id) != _blk_ids.end();
 }

◆ hasBlocks() [5/6]

bool BlockRestrictable::hasBlocks ( const std::vector< SubdomainID > & ids ) const

inherited

Test if the supplied vector block ids are valid for this object.

Parameters

ids	A vector of SubdomainIDs ids to check

Returns: True if all of the given ids are found within the ids for this object

Definition at line 240 of file BlockRestrictable.C.

 {
   std::set<SubdomainID> ids_set(ids.begin(), ids.end());
   return hasBlocks(ids_set);
 }

◆ hasBlocks() [6/6]

bool BlockRestrictable::hasBlocks ( const std::set< SubdomainID > & ids ) const

inherited

Test if the supplied set of block ids are valid for this object.

Parameters

ids	A std::set of SubdomainIDs to check

Returns: True if all of the given ids are found within the ids for this object

See also: isSubset

Definition at line 247 of file BlockRestrictable.C.

 {
   if (_blk_ids.empty() || _blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return true;
   else
     return std::includes(_blk_ids.begin(), _blk_ids.end(), ids.begin(), ids.end());
 }

◆ hasLocalApp()

bool MultiApp::hasLocalApp ( unsigned int global_app ) const

inherited

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 1071 of file MultiApp.C.

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

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

◆ incrementTStep()

void TransientMultiApp::incrementTStep ( Real )

overridevirtualinherited

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

Definition at line 548 of file TransientMultiApp.C.

 {
   if (!_sub_cycling)
   {
     for (unsigned int i = 0; i < _my_num_apps; i++)
     {
       TransientBase * ex = _transient_executioners[i];
 
       // The App might have a different local time from the rest of the problem
       Real app_time_offset = _apps[i]->getGlobalTimeOffset();
 
       // Only increment the step if we are after (target_time) the
       // start_time (added to app_time_offset) of this sub_app.
       if (_apps[i]->getStartTime() + app_time_offset < target_time)
         ex->incrementStepOrReject();
     }
   }
 }

◆ init() [1/2]

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

protectedinherited

Build communicators and reserve backups.

Definition at line 340 of file MultiApp.C.

Referenced by MultiApp::setupPositions().

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

◆ init() [2/2]

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

protectedinherited

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

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

◆ initializeBlockRestrictable()

void BlockRestrictable::initializeBlockRestrictable ( const MooseObject * moose_object )

protectedinherited

An initialization routine needed for dual constructors.

Definition at line 74 of file BlockRestrictable.C.

Referenced by BlockRestrictable::BlockRestrictable().

 {
   // If the mesh pointer is not defined, but FEProblemBase is, get it from there
   if (_blk_feproblem != NULL && _blk_mesh == NULL)
     _blk_mesh = &_blk_feproblem->mesh();
 
   // Check that the mesh pointer was defined, it is required for this class to operate
   if (_blk_mesh == NULL)
     mooseError("The input parameters must contain a pointer to FEProblem via '_fe_problem' or a "
                "pointer to the MooseMesh via '_mesh'");
 
   // Populate the MaterialData pointer
   if (_blk_feproblem != NULL)
     _blk_material_data = &_blk_feproblem->getMaterialData(Moose::BLOCK_MATERIAL_DATA, _blk_tid);
 
   // The 'block' input is defined
   if (moose_object->isParamValid("block"))
   {
     // Extract the blocks from the input
     _blocks = moose_object->getParam<std::vector<SubdomainName>>("block");
 
     // Store the IDs in a set, handling ANY_BLOCK_ID if supplied
     if (std::find(_blocks.begin(), _blocks.end(), "ANY_BLOCK_ID") != _blocks.end())
       _blk_ids.insert(Moose::ANY_BLOCK_ID);
     else
     {
       // Get the IDs from the supplied names
       _vec_ids = _blk_mesh->getSubdomainIDs(_blocks);
       _blk_ids.insert(_vec_ids.begin(), _vec_ids.end());
     }
   }
 
   // When 'blocks' is not set and there is a "variable", use the blocks from the variable
   else if (moose_object->isParamValid("variable"))
   {
     std::string variable_name = moose_object->parameters().getMooseType("variable");
     if (!variable_name.empty())
       _blk_ids = _blk_feproblem
                      ->getVariable(_blk_tid,
                                    variable_name,
                                    Moose::VarKindType::VAR_ANY,
                                    Moose::VarFieldType::VAR_FIELD_ANY)
                      .activeSubdomains();
   }
 
   // Produce error if the object is not allowed to be both block and boundary restricted
   if (!_blk_dual_restrictable && !_boundary_ids.empty() && !_boundary_ids.empty())
     if (!_boundary_ids.empty() && _boundary_ids.find(Moose::ANY_BOUNDARY_ID) == _boundary_ids.end())
       moose_object->paramError("block",
                                "Attempted to restrict the object '",
                                _blk_name,
                                "' to a block, but the object is already restricted by boundary");
 
   // If no blocks were defined above, specify that it is valid on all blocks
   if (_blk_ids.empty() && !moose_object->isParamValid("boundary"))
   {
     _blk_ids.insert(Moose::ANY_BLOCK_ID);
     _blocks = {"ANY_BLOCK_ID"};
   }
 
   // If this object is block restricted, check that defined blocks exist on the mesh
   if (_blk_ids.find(Moose::ANY_BLOCK_ID) == _blk_ids.end())
   {
     const std::set<SubdomainID> & valid_ids = _blk_mesh->meshSubdomains();
     std::vector<SubdomainID> diff;
 
     std::set_difference(_blk_ids.begin(),
                         _blk_ids.end(),
                         valid_ids.begin(),
                         valid_ids.end(),
                         std::back_inserter(diff));
 
     if (!diff.empty())
     {
       std::ostringstream msg;
       auto sep = " ";
       msg << "the following blocks (ids) do not exist on the mesh:";
       for (const auto & id : diff)
       {
         if (_blk_name.size() > 0)
         {
           auto & name =
               _blocks.at(std::find(_vec_ids.begin(), _vec_ids.end(), id) - _vec_ids.begin());
           if (std::to_string(id) != name)
             msg << sep << name << " (" << id << ")";
           else
             msg << sep << id;
         }
         else
           msg << sep << id;
         sep = ", ";
       }
       std::vector<SubdomainID> valid_ids_vec(valid_ids.begin(), valid_ids.end());
       auto valid_names = _blk_mesh->getSubdomainNames(valid_ids_vec);
       msg << "\nBlocks names (resp. ids) that do exist: " << Moose::stringify(valid_names) << " ("
           << Moose::stringify(valid_ids) << ")";
       moose_object->paramError("block", msg.str());
     }
   }
 
   // Get the mesh dimension for the blocks
   if (blockRestricted())
     _blk_dim = _blk_mesh->getBlocksMaxDimension(_blocks);
   else
     _blk_dim = _blk_mesh->dimension();
 }

◆ initialSetup()

void TransientMultiApp::initialSetup ( )

overridevirtualinherited

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

Reimplemented from MultiApp.

Definition at line 155 of file TransientMultiApp.C.

 {
   MultiApp::initialSetup();
 
   if (!_has_an_app)
     return;
 
   Moose::ScopedCommSwapper swapper(_my_comm);
 
   if (_has_an_app)
   {
     _transient_executioners.resize(_my_num_apps);
     // Grab Transient Executioners from each app
     for (unsigned int i = 0; i < _my_num_apps; i++)
       setupApp(i);
   }
 }

◆ isBlockSubset() [1/2]

bool BlockRestrictable::isBlockSubset ( const std::set< SubdomainID > & ids ) const

inherited

Test if the class block ids are a subset of the supplied objects.

Parameters

ids	A std::set of Subdomains to check

Returns: True if all of the block ids for this class are found within the given ids (opposite of hasBlocks)

See also: hasBlocks

Definition at line 256 of file BlockRestrictable.C.

Referenced by BlockRestrictable::checkVariable(), BlockRestrictable::isBlockSubset(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), and ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux().

 {
   // An empty input is assumed to be ANY_BLOCK_ID
   if (ids.empty() || ids.find(Moose::ANY_BLOCK_ID) != ids.end())
     return true;
 
   if (_blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return std::includes(ids.begin(),
                          ids.end(),
                          _blk_mesh->meshSubdomains().begin(),
                          _blk_mesh->meshSubdomains().end());
   else
     return std::includes(ids.begin(), ids.end(), _blk_ids.begin(), _blk_ids.end());
 }

◆ isBlockSubset() [2/2]

bool BlockRestrictable::isBlockSubset ( const std::vector< SubdomainID > & ids ) const

inherited

Test if the class block ids are a subset of the supplied objects.

Parameters

ids	A std::vector of Subdomains to check

Returns: True if all of the block ids for this class are found within the given ids (opposite of hasBlocks)

See also: hasBlocks

Definition at line 272 of file BlockRestrictable.C.

 {
   std::set<SubdomainID> ids_set(ids.begin(), ids.end());
   return isBlockSubset(ids_set);
 }

◆ isFirstLocalRank()

bool MultiApp::isFirstLocalRank ( ) const

inherited

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

Definition at line 1065 of file MultiApp.C.

 {
   return _rank_config.is_first_local_rank;
 }

◆ isParamSetByUser()

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

inlineinherited

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

Parameters

nm	The name of the parameter to test

Definition at line 128 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), MooseBaseParameterInterface::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MFEMSolverBase::setPreconditioner(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

128 { return _pars.isParamSetByUser(nm); }

InputParameters::isParamSetByUser

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

Method returns true if the parameter was set by the user.

Definition: InputParameters.C:1178

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 122 of file MooseBaseParameterInterface.h.

122 { return _pars.isParamValid(name); }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

InputParameters::isParamValid

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

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

Definition: InputParameters.C:390

◆ isRootProcessor()

bool MultiApp::isRootProcessor ( )

inlineinherited

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

MultiApp::_my_rank

int _my_rank

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

Definition: MultiApp.h:538

◆ jacobianSetup()

void SetupInterface::jacobianSetup ( )

virtualinherited

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

Reimplemented in MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< T >, MooseVariableFE< RealEigenVector >, MooseVariableFE< VectorValue< Real > >, MooseVariableFE< RealVectorValue >, MooseVariableFE< Real >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< RT >, MooseVariableField< ComputeValueType >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, Positions, Times, DiffusionLHDGKernel, IPHDGKernel, EqualValueEmbeddedConstraintTempl< is_ad >, ADKernelTempl< T >, IPHDGBC, DiffusionLHDGPrescribedGradientBC, and DiffusionLHDGDirichletBC.

Definition at line 51 of file SetupInterface.C.

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

52 {

53 }

◆ keepSolutionDuringRestore()

void MultiApp::keepSolutionDuringRestore ( bool keep_solution_during_restore )

protectedinherited

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

Definition at line 893 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 )

inherited

Get the local MooseApp object.

Parameters

local_app The local app number

Definition at line 1081 of file MultiApp.C.

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

◆ meshBlockIDs()

const std::set< SubdomainID > & BlockRestrictable::meshBlockIDs ( ) const

inherited

Return all of the SubdomainIDs for the mesh.

Returns: A set of all subdomians for the entire mesh

Definition at line 279 of file BlockRestrictable.C.

Referenced by BlockRestrictable::checkVariable(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), BlockRestrictable::getBlockCoordSystem(), BlockRestrictable::hasBlockMaterialPropertyHelper(), and SolutionIC::initialSetup().

 {
   return _blk_mesh->meshSubdomains();
 }

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

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

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Emits a documented error with object name and type.

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

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

Parameters

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

Definition at line 61 of file MooseBaseErrorInterface.h.

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

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

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

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

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 40 of file MooseBaseErrorInterface.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 98 of file MooseBaseErrorInterface.h.

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

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

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

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

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

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 85 of file MooseBaseErrorInterface.h.

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

◆ moveApp()

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

virtualinherited

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 1109 of file MultiApp.C.

Referenced by MultiApp::preTransfer().

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

◆ name()

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

inlinevirtualinherited

Get the name of the class.

Returns: The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

57 { return _name; }

MooseBase::_name

const std::string _name

The name of this class.

Definition: MooseBase.h:90

◆ needsRestoration()

bool MultiApp::needsRestoration ( )

inlineinherited

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

Definition at line 210 of file MultiApp.h.

Referenced by MultiApp::restore().

210 { return !_no_restore; }

MultiApp::_no_restore

const bool _no_restore

Whether or not to skip restoring completely.

Definition: MultiApp.h:604

◆ numBlocks()

unsigned int BlockRestrictable::numBlocks ( ) const

inherited

Return the number of blocks for this object.

Returns: The number of subdomains

Definition at line 203 of file BlockRestrictable.C.

Referenced by ElementCentroidPositions::initialize(), and QuadraturePointsPositions::initialize().

 {
   return (unsigned int)_blk_ids.size();
 }

◆ numGlobalApps()

unsigned int MultiApp::numGlobalApps ( ) const

inlineinherited

Returns: Number of Global Apps in this MultiApp

Definition at line 278 of file MultiApp.h.

278 { return _total_num_apps; }

MultiApp::_total_num_apps

unsigned int _total_num_apps

The total number of apps to simulate.

Definition: MultiApp.h:511

◆ numLocalApps()

unsigned int MultiApp::numLocalApps ( )

inlineinherited

Returns: Number of Apps on local processor.

Definition at line 283 of file MultiApp.h.

283 { return _apps.size(); }

MultiApp::_apps

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

Pointers to each of the Apps.

Definition: MultiApp.h:541

◆ paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 255 of file MooseBaseParameterInterface.h.

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

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

62 { return _pars; }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

◆ paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 272 of file MooseBaseParameterInterface.h.

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

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

◆ paramWarning()

template<typename... Args>

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

inherited

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

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

Definition at line 265 of file MooseBaseParameterInterface.h.

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

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

◆ parentOutputPositionChanged()

void MultiApp::parentOutputPositionChanged ( )

virtualinherited

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

Definition at line 1128 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 78 of file PerfGraphInterface.C.

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

 {
   return _pg_moose_app.perfGraph();
 }

◆ position()

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

inherited

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 1513 of file MultiApp.C.

Referenced by MultiApp::getBoundingBox().

 {
   // 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);
 }

◆ postExecute()

void MultiApp::postExecute ( )

virtualinherited

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

Reimplemented in FullSolveMultiApp.

Definition at line 748 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 ( )

inlinevirtualinherited

Definition at line 122 of file MultiApp.h.

122 {}

◆ preRunInputFile()

void MultiApp::preRunInputFile ( )

protectedvirtualinherited

call back executed right before app->runInputFile()

Definition at line 1470 of file MultiApp.C.

Referenced by MultiApp::createApp().

1471 {

1472 }

◆ preTransfer()

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

virtualinherited

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

Definition at line 658 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];
           if (usingPositions())
             app_ptr->getExecutioner()->feProblem().coordTransform().transformMesh(
                 app_ptr->getExecutioner()->feProblem().mesh(), _positions[_first_local_app + i]);
           else
             app_ptr->getExecutioner()->feProblem().coordTransform().transformMesh(
                 app_ptr->getExecutioner()->feProblem().mesh(), Point(0, 0, 0));
         }
 
       // 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 ( )

inlineinherited

Get the FEProblemBase this MultiApp is part of.

Definition at line 237 of file MultiApp.h.

237 { return _fe_problem; }

MultiApp::_fe_problem

FEProblemBase & _fe_problem

The FEProblemBase this MultiApp is part of.

Definition: MultiApp.h:482

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

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

Definition at line 222 of file MooseBaseParameterInterface.h.

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

◆ readCommandLineArguments()

void MultiApp::readCommandLineArguments ( )

protectedinherited

Fill command line arguments for sub apps.

Definition at line 447 of file MultiApp.C.

Referenced by MultiApp::createApps().

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

◆ registerTimedSection() [1/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

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

Definition at line 53 of file PerfGraphInterface.C.

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

◆ registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

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

Definition at line 64 of file PerfGraphInterface.C.

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

◆ resetApp()

void TransientMultiApp::resetApp	(	unsigned int	global_app,
		Real	time
	)

overridevirtualinherited

"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 from MultiApp.

Definition at line 620 of file TransientMultiApp.C.

 {
   if (hasLocalApp(global_app))
   {
     unsigned int local_app = globalAppToLocal(global_app);
 
     // Grab the current time the App is at so we can start the new one at the same place
     Real time =
         _transient_executioners[local_app]->getTime() + _apps[local_app]->getGlobalTimeOffset();
 
     // Reset the Multiapp
     MultiApp::resetApp(global_app, time);
 
     Moose::ScopedCommSwapper swapper(_my_comm);
 
     // Setup the app, disable the output so that the initial condition does not output
     // When an app is reset the initial condition was effectively already output before reset
     FEProblemBase & problem = appProblemBase(local_app);
     problem.allowOutput(false);
     setupApp(local_app, time);
     problem.allowOutput(true);
   }
 }

◆ residualSetup()

void SetupInterface::residualSetup ( )

virtualinherited

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

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

Definition at line 56 of file SetupInterface.C.

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

57 {

58 }

◆ restartableName()

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

protectedinherited

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

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

Definition at line 66 of file Restartable.C.

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

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

◆ restore()

void MultiApp::restore ( bool force = true )

virtualinherited

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 775 of file MultiApp.C.

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

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

◆ runningInPosition()

bool MultiApp::runningInPosition ( ) const

inlineinherited

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

MultiApp::_run_in_position

const bool _run_in_position

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

Definition: MultiApp.h:620

◆ setAppOutputFileBase() [1/2]

void MultiApp::setAppOutputFileBase ( )

inherited

Sets all the app's output file bases.

See also: MooseApp::setOutputFileBase for usage

Definition at line 1481 of file MultiApp.C.

Referenced by MultiApp::createApp().

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

◆ setAppOutputFileBase() [2/2]

void MultiApp::setAppOutputFileBase ( unsigned int index )

protectedinherited

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

inherited

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

Definition at line 377 of file MultiApp.C.

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

◆ solveStep()

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

overridevirtualinherited

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)

Implements MultiApp.

Definition at line 174 of file TransientMultiApp.C.

 {
   if (!_has_an_app)
     return true;
 
   TIME_SECTION(_solve_step_timer);
 
   _auto_advance = auto_advance;
 
   if (_fe_problem.verboseMultiApps())
     _console << COLOR_CYAN << "Solving MultiApp '" << name() << "' with target time " << target_time
              << " and dt " << dt << " with auto-advance " << (auto_advance ? "on" : "off")
              << COLOR_DEFAULT << std::endl;
 
   // "target_time" must always be in global time
   target_time += _app.getGlobalTimeOffset();
 
   Moose::ScopedCommSwapper swapper(_my_comm);
   bool return_value = true;
 
   // Make sure we swap back the communicator regardless of how this routine is exited
   try
   {
     int rank;
     int ierr;
     ierr = MPI_Comm_rank(_communicator.get(), &rank);
     mooseCheckMPIErr(ierr);
 
     for (unsigned int i = 0; i < _my_num_apps; i++)
     {
       FEProblemBase & problem = appProblemBase(_first_local_app + i);
 
       TransientBase * ex = _transient_executioners[i];
 
       // The App might have a different local time from the rest of the problem
       Real app_time_offset = _apps[i]->getGlobalTimeOffset();
 
       // Maybe this MultiApp was already solved
       if ((ex->getTime() + app_time_offset + ex->timestepTol() >= target_time) ||
           (ex->getTime() >= ex->endTime()))
         continue;
 
       // Examine global time synchronization
       if (!_sub_cycling && !_reset_happened.size())
       {
         // The multi-app general offset is substracted to go into local time.
         if (std::abs(target_time - _app.getGlobalTimeOffset() - ex->getTime() - dt) >
             ex->timestepTol())
           mooseDoOnce(mooseWarning(
               "The target time (time a multiapp must reach at the end of the time step) "
               "is desynchronized between this app and subapp ",
               i,
               ".\n If this is desired: use the 'global_time_offset' multiapp parameter to "
               "declare a constant offset\n"
               "If the apps should (eventually) be synchronized in time, please either: \n"
               "  - match the 'start_time' in the main app and the multiapp, in the Executioner "
               "block\n"
               "  - set 'sub_cycling' to true in the multiapp parameters\n"
               "This message will only print once for all apps and all time steps."));
       }
 
       if (_sub_cycling)
       {
         Real time_old = ex->getTime() + app_time_offset;
 
         if (_interpolate_transfers)
         {
           AuxiliarySystem & aux_system = problem.getAuxiliarySystem();
           System & libmesh_aux_system = aux_system.system();
 
           NumericVector<Number> & solution = *libmesh_aux_system.solution;
           NumericVector<Number> & transfer_old = libmesh_aux_system.get_vector("transfer_old");
 
           solution.close();
 
           // Save off the current auxiliary solution
           transfer_old = solution;
 
           transfer_old.close();
 
           // Snag all of the local dof indices for all of these variables
           AllLocalDofIndicesThread aldit(problem, _transferred_vars);
           ConstElemRange & elem_range = *problem.mesh().getActiveLocalElementRange();
           Threads::parallel_reduce(elem_range, aldit);
 
           _transferred_dofs = aldit.getDofIndices();
         }
 
         // Disable/enable output for sub cycling
         problem.allowOutput(_output_sub_cycles);         // disables all outputs, including console
         problem.allowOutput<Console>(_print_sub_cycles); // re-enables Console to print, if desired
 
         ex->setTargetTime(target_time - app_time_offset);
 
         //      unsigned int failures = 0;
 
         bool at_steady = false;
 
         // ADL: During restart, there is already an FEProblemBase::advanceState that occurs at the
         // end of TransientMultiApp::setupApp. advanceState, along with copying the solutions
         // backwards in time/state, also *moves* (note it doesn't copy!) stateful material
         // properties backwards (through swapping). So if restarting from a full-solve steady
         // multi-app for example, then after one advance state, we will have good information in old
         // and no information in current. But then if we advance again we no longer have good data
         // in the old material properties, so don't advance here if we're restarting
         if (_first && !_app.isRecovering() && !_app.isRestarting())
           problem.advanceState();
 
         bool local_first = _first;
 
         // Now do all of the solves we need
         while ((!at_steady && ex->getTime() + app_time_offset + ex->timestepTol() < target_time) ||
                !ex->lastSolveConverged())
         {
           if (local_first != true)
             ex->incrementStepOrReject();
 
           local_first = false;
 
           ex->preStep();
           ex->computeDT();
 
           if (_interpolate_transfers)
           {
             // See what time this executioner is going to go to.
             Real future_time = ex->getTime() + app_time_offset + ex->getDT();
 
             // How far along we are towards the target time:
             Real step_percent = (future_time - time_old) / (target_time - time_old);
 
             Real one_minus_step_percent = 1.0 - step_percent;
 
             // Do the interpolation for each variable that was transferred to
             FEProblemBase & problem = appProblemBase(_first_local_app + i);
             AuxiliarySystem & aux_system = problem.getAuxiliarySystem();
             System & libmesh_aux_system = aux_system.system();
 
             NumericVector<Number> & solution = *libmesh_aux_system.solution;
             NumericVector<Number> & transfer = libmesh_aux_system.get_vector("transfer");
             NumericVector<Number> & transfer_old = libmesh_aux_system.get_vector("transfer_old");
 
             solution.close(); // Just to be sure
             transfer.close();
             transfer_old.close();
 
             for (const auto & dof : _transferred_dofs)
             {
               solution.set(dof,
                            (transfer_old(dof) * one_minus_step_percent) +
                                (transfer(dof) * step_percent));
               //            solution.set(dof, transfer_old(dof));
               //            solution.set(dof, transfer(dof));
               //            solution.set(dof, 1);
             }
 
             solution.close();
           }
 
           ex->takeStep();
 
           bool converged = ex->lastSolveConverged();
 
           if (!converged)
           {
             mooseWarning(
                 "While sub_cycling ", name(), _first_local_app + i, " failed to converge!\n");
 
             _failures++;
 
             if (_failures > _max_failures)
             {
               std::stringstream oss;
               oss << "While sub_cycling " << name() << _first_local_app << i << " REALLY failed!";
               throw MultiAppSolveFailure(oss.str());
             }
           }
           if (_detect_steady_state)
             at_steady = ex->convergedToSteadyState();
 
           if (converged && _detect_steady_state && at_steady)
           {
             if (_fe_problem.verboseMultiApps())
               _console << "Detected Steady State! Fast-forwarding to " << target_time << std::endl;
 
             // Indicate that the next output call (occurs in ex->endStep()) should output,
             // regardless of intervals etc...
             problem.forceOutput();
 
             // Clean up the end
             ex->endStep(target_time - app_time_offset);
             ex->postStep();
           }
           else
           {
             ex->endStep();
             ex->postStep();
           }
         }
 
         // If we were looking for a steady state, but didn't reach one, we still need to output one
         // more time, regardless of interval
         // Note: if we turn off the output for all time steps for sub-cycling, we still need to
         // have one output at the end.
         if ((!at_steady && _detect_steady_state) || !_output_sub_cycles)
           problem.outputStep(EXEC_FORCED);
 
       } // sub_cycling
       else if (_tolerate_failure)
       {
         ex->takeStep(dt);
         ex->endStep(target_time - app_time_offset);
         ex->postStep();
       }
       else
       {
         // ADL: During restart, there is already an FEProblemBase::advanceState that occurs at the
         // end of TransientMultiApp::setupApp. advanceState, along with copying the solutions
         // backwards in time/state, also *moves* (note it doesn't copy!) stateful material
         // properties backwards (through swapping). So if restarting from a full-solve steady
         // multi-app for example, then after one advance state, we will have good information in old
         // and no information in current. But then if we advance again we no longer have good data
         // in the old material properties, so don't advance here if we're restarting
         if (_first && !_app.isRecovering() && !_app.isRestarting())
           problem.advanceState();
 
         if (auto_advance)
           problem.allowOutput(true);
 
         ex->takeStep(dt);
 
         if (auto_advance)
         {
           ex->endStep();
           ex->postStep();
 
           if (!ex->lastSolveConverged())
           {
             mooseWarning(name(), _first_local_app + i, " failed to converge!\n");
 
             if (_catch_up)
             {
               if (_fe_problem.verboseMultiApps())
                 _console << "Starting time step catch up!" << std::endl;
 
               bool caught_up = false;
 
               unsigned int catch_up_step = 0;
 
               // Cut the timestep in half to first try two half-step solves
               Real catch_up_dt = dt / 2;
               Real catch_up_time = 0;
 
               while (!caught_up && catch_up_step < _max_catch_up_steps)
               {
                 if (_fe_problem.verboseMultiApps())
                   _console << "Solving " << name() << " catch up step " << catch_up_step
                            << std::endl;
                 ex->incrementStepOrReject();
 
                 // Avoid numerical precision errors on target time
                 if (catch_up_time + catch_up_dt > dt)
                   catch_up_dt = dt - catch_up_time;
 
                 ex->computeDT();
                 ex->takeStep(catch_up_dt);
                 ex->endStep();
 
                 if (ex->lastSolveConverged())
                 {
                   catch_up_time += catch_up_dt;
                   if (std::abs(catch_up_time - dt) <
                       (1 + std::abs(ex->getTime())) * ex->timestepTol())
                   {
                     problem.outputStep(EXEC_FORCED);
                     caught_up = true;
                   }
                 }
                 else
                   // Keep cutting time step in half until it converges
                   catch_up_dt /= 2.0;
 
                 ex->postStep();
 
                 catch_up_step++;
               }
 
               if (!caught_up)
                 throw MultiAppSolveFailure(name() + " Failed to catch up!\n");
             }
           }
         }
         else // auto_advance == false
         {
           if (!ex->lastSolveConverged())
           {
             // Even if we don't allow auto_advance - we can still catch up to the current time if
             // possible
             if (_catch_up)
             {
               if (_fe_problem.verboseMultiApps())
                 _console << "Starting Catch Up!" << std::endl;
 
               bool caught_up = false;
 
               unsigned int catch_up_step = 0;
 
               Real catch_up_dt = dt / 2;
 
               // Note: this loop will _break_ if target_time is satisfied
               while (catch_up_step < _max_catch_up_steps)
               {
                 if (_fe_problem.verboseMultiApps())
                   _console << "Solving " << name() << " catch up step " << catch_up_step
                            << std::endl;
                 ex->incrementStepOrReject();
 
                 ex->computeDT();
                 ex->takeStep(catch_up_dt); // Cut the timestep in half to try two half-step solves
 
                 // This is required because we can't call endStep() yet
                 // (which normally increments time)
                 Real current_time = ex->getTime() + ex->getDT();
 
                 if (ex->lastSolveConverged())
                 {
                   if (current_time + app_time_offset +
                           (ex->timestepTol() * std::abs(current_time)) >=
                       target_time)
                   {
                     caught_up = true;
                     break; // break here so that we don't run endStep() or postStep() since this
                            // MultiApp should NOT be auto_advanced
                   }
                 }
                 else
                   catch_up_dt /= 2.0;
 
                 ex->endStep();
                 ex->postStep();
 
                 catch_up_step++;
               }
 
               if (!caught_up)
                 throw MultiAppSolveFailure(name() + " Failed to catch up!\n");
             }
             else
               throw MultiAppSolveFailure(name() + " failed to converge");
           }
         }
       }
 
       // Re-enable all output (it may of been disabled by sub-cycling)
       problem.allowOutput(true);
     }
 
     _first = false;
 
     if (_fe_problem.verboseMultiApps())
       _console << "Successfully Solved MultiApp " << name() << "." << std::endl;
   }
   catch (MultiAppSolveFailure & e)
   {
     mooseWarning(e.what());
     _console << "Failed to Solve MultiApp " << name() << ", attempting to recover." << std::endl;
     return_value = false;
   }
 
   _transferred_vars.clear();
 
   return return_value;
 }

◆ subdomainSetup()

void SetupInterface::subdomainSetup ( )

virtualinherited

Gets called when the subdomain changes (i.e.

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

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

Definition at line 61 of file SetupInterface.C.

62 {

63 }

◆ timedSectionName()

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

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

◆ timestepSetup()

void SetupInterface::timestepSetup ( )

virtualinherited

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

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

Definition at line 46 of file SetupInterface.C.

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

47 {

48 }

◆ transformBoundingBox()

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

staticinherited

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

Definition at line 903 of file MultiApp.C.

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

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

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 51 of file MooseBase.h.

51 { return _type; }

MooseBase::_type

const std::string _type

The type of this class.

Definition: MooseBase.h:87

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

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

Definition at line 27 of file MooseBase.C.

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

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

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const

inlineinherited

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

Definition at line 67 of file MooseBaseParameterInterface.h.

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

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

◆ uniqueParameterName()

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

inlineinherited

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

Definition at line 52 of file MooseBaseParameterInterface.h.

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

◆ usingPositions()

bool MultiApp::usingPositions ( ) const

inlineinherited

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

Definition at line 363 of file MultiApp.h.

Referenced by MultiApp::createApp(), and MultiApp::preTransfer().

363 { return _use_positions; }

MultiApp::_use_positions

const bool _use_positions

Toggle use of "positions".

Definition: MultiApp.h:496

◆ validParams()

InputParameters QuadraturePointMultiApp::validParams ( )

static

Definition at line 27 of file QuadraturePointMultiApp.C.

 {
   InputParameters params = TransientMultiApp::validParams();
   params += BlockRestrictable::validParams();
   params.addClassDescription(
       "Automatically generates sub-App positions from the elemental quadrature points, with the "
       "default quadrature, in the parent mesh.");
   params.suppressParameter<std::vector<Point>>("positions");
   params.suppressParameter<std::vector<FileName>>("positions_file");
   params.suppressParameter<std::vector<PositionsName>>("positions_objects");
   return params;
 }

Member Data Documentation

◆ _action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory

protectedinherited

Builds Actions.

Definition at line 179 of file MooseBaseParameterInterface.h.

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

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

◆ _app_type

std::string MultiApp::_app_type

protectedinherited

The type of application to build.

Definition at line 485 of file MultiApp.h.

Referenced by MultiApp::createApp(), and MultiApp::createApps().

◆ _apps

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

protectedinherited

◆ _associated_transfers

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

protectedinherited

Transfers associated with this multiapp.

Definition at line 617 of file MultiApp.h.

Referenced by MultiApp::addAssociatedTransfer(), and MultiApp::preTransfer().

◆ _backup_timer

const PerfID MultiApp::_backup_timer

protectedinherited

Definition at line 628 of file MultiApp.h.

Referenced by MultiApp::backup().

◆ _blk_material_data

const MaterialData* BlockRestrictable::_blk_material_data

protectedinherited

Pointer to the MaterialData class for this object.

Definition at line 214 of file BlockRestrictable.h.

Referenced by BlockRestrictable::hasBlockMaterialProperty(), and BlockRestrictable::initializeBlockRestrictable().

◆ _bounding_box

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

protectedinherited

This multi-app's bounding box.

Definition at line 547 of file MultiApp.h.

Referenced by MultiApp::getBoundingBox(), and MultiApp::init().

◆ _bounding_box_padding

Point MultiApp::_bounding_box_padding

protectedinherited

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

Definition at line 553 of file MultiApp.h.

Referenced by MultiApp::getBoundingBox().

◆ _cli_args

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

protectedinherited

CommandLine arguments (controllable!)

Definition at line 592 of file MultiApp.h.

Referenced by MultiApp::cliArgs(), and MultiApp::init().

◆ _cli_args_from_file

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

protectedinherited

CommandLine arguments from files.

Definition at line 595 of file MultiApp.h.

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

◆ _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 78 of file SetupInterface.h.

Referenced by PseudoTimestep::execute().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 51 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _end_aux_solutions

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

protectedinherited

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

Definition at line 611 of file MultiApp.h.

Referenced by MultiApp::restore().

◆ _end_solutions

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

protectedinherited

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 608 of file MultiApp.h.

Referenced by MultiApp::restore().

◆ _execute_enum

const ExecFlagEnum& SetupInterface::_execute_enum

protectedinherited

Execute settings for this object.

Definition at line 75 of file SetupInterface.h.

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

◆ _factory

Factory& MooseBaseParameterInterface::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 176 of file MooseBaseParameterInterface.h.

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

◆ _fe_problem

FEProblemBase& MultiApp::_fe_problem

protectedinherited

The FEProblemBase this MultiApp is part of.

Definition at line 482 of file MultiApp.h.

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

◆ _first_local_app

unsigned int MultiApp::_first_local_app

protectedinherited

The number of the first app on this processor.

Definition at line 517 of file MultiApp.h.

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

◆ _global_time_offset

const Real MultiApp::_global_time_offset

protectedinherited

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

Definition at line 565 of file MultiApp.h.

Referenced by MultiApp::createLocalApp().

◆ _has_an_app

bool MultiApp::_has_an_app

protectedinherited

Whether or not this processor as an App at all

Definition at line 589 of file MultiApp.h.

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

◆ _has_bounding_box

std::vector<bool> MultiApp::_has_bounding_box

protectedinherited

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

Definition at line 544 of file MultiApp.h.

Referenced by MultiApp::getBoundingBox(), and MultiApp::init().

◆ _inflation

Real MultiApp::_inflation

protectedinherited

Relative bounding box inflation.

Definition at line 550 of file MultiApp.h.

Referenced by MultiApp::getBoundingBox().

◆ _init_timer

const PerfID MultiApp::_init_timer

protectedinherited

Definition at line 627 of file MultiApp.h.

Referenced by MultiApp::init().

◆ _input_files

std::vector<FileName> MultiApp::_input_files

protectedinherited

The input file for each app's simulation.

Definition at line 499 of file MultiApp.h.

Referenced by MultiApp::createApp(), and MultiApp::fillPositions().

◆ _keep_aux_solution_during_restore

bool MultiApp::_keep_aux_solution_during_restore

protectedinherited

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

Definition at line 601 of file MultiApp.h.

Referenced by MultiApp::restore().

◆ _keep_solution_during_restore

bool MultiApp::_keep_solution_during_restore

protectedinherited

Flag indicates if or not restart from the latest solution.

Definition at line 598 of file MultiApp.h.

Referenced by MultiApp::keepSolutionDuringRestore(), MultiApp::restore(), and TransientMultiApp::TransientMultiApp().

◆ _max_procs_per_app

processor_id_type MultiApp::_max_procs_per_app

protectedinherited

Maximum number of processors to give to each app.

Definition at line 556 of file MultiApp.h.

Referenced by MultiApp::init().

◆ _min_procs_per_app

processor_id_type MultiApp::_min_procs_per_app

protectedinherited

Minimum number of processors to give to each app.

Definition at line 559 of file MultiApp.h.

Referenced by MultiApp::init().

◆ _move_apps

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

protectedinherited

The apps to be moved.

Definition at line 580 of file MultiApp.h.

Referenced by MultiApp::fillPositions(), and MultiApp::preTransfer().

◆ _move_happened

bool MultiApp::_move_happened

protectedinherited

Whether or not the move has happened.

Definition at line 586 of file MultiApp.h.

Referenced by MultiApp::preTransfer().

◆ _move_positions

std::vector<Point> MultiApp::_move_positions

protectedinherited

The new positions for the apps to be moved.

Definition at line 583 of file MultiApp.h.

Referenced by MultiApp::fillPositions(), and MultiApp::preTransfer().

◆ _move_time

Real MultiApp::_move_time

protectedinherited

The time at which to move apps.

Definition at line 577 of file MultiApp.h.

Referenced by MultiApp::preTransfer().

◆ _my_comm

MPI_Comm& MultiApp::_my_comm

protectedinherited

The MPI communicator this object is going to use.

Definition at line 526 of file MultiApp.h.

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

◆ _my_communicator

libMesh::Parallel::Communicator MultiApp::_my_communicator

protectedinherited

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

Definition at line 523 of file MultiApp.h.

Referenced by MultiApp::buildComm().

◆ _my_num_apps

unsigned int MultiApp::_my_num_apps

protectedinherited

The number of apps this object is involved in simulating.

Definition at line 514 of file MultiApp.h.

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

◆ _my_rank

int MultiApp::_my_rank

protectedinherited

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

Definition at line 538 of file MultiApp.h.

Referenced by MultiApp::buildComm(), and MultiApp::isRootProcessor().

◆ _name

const std::string MooseBase::_name

protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

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

◆ _no_restore

const bool MultiApp::_no_restore

protectedinherited

Whether or not to skip restoring completely.

Definition at line 604 of file MultiApp.h.

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

◆ _node_name

std::string MultiApp::_node_name

protectedinherited

Node Name.

Definition at line 535 of file MultiApp.h.

Referenced by MultiApp::buildComm().

◆ _npositions_inputfile

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

protectedinherited

Number of positions for each input file.

Definition at line 505 of file MultiApp.h.

Referenced by MultiApp::fillPositions(), and MultiApp::readCommandLineArguments().

◆ _orig_comm

const MPI_Comm& MultiApp::_orig_comm

protectedinherited

The original comm handle.

Definition at line 520 of file MultiApp.h.

Referenced by MultiApp::createApps().

◆ _orig_num_procs

int MultiApp::_orig_num_procs

protectedinherited

The number of processors in the original comm.

Definition at line 529 of file MultiApp.h.

Referenced by MultiApp::buildComm().

◆ _orig_rank

int MultiApp::_orig_rank

protectedinherited

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

Definition at line 532 of file MultiApp.h.

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

◆ _output_base

std::string MultiApp::_output_base

protectedinherited

The output file basename for each multiapp.

Definition at line 508 of file MultiApp.h.

◆ _output_in_position

bool MultiApp::_output_in_position

protectedinherited

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

Definition at line 562 of file MultiApp.h.

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

◆ _pars

const InputParameters& MooseBaseParameterInterface::_pars

protectedinherited

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

Definition at line 173 of file MooseBaseParameterInterface.h.

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _positions

std::vector<Point> MultiApp::_positions

protectedinherited

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

Definition at line 488 of file MultiApp.h.

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

◆ _positions_index_offsets

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

protectedinherited

The offsets, in case multiple Positions objects are specified.

Definition at line 492 of file MultiApp.h.

Referenced by MultiApp::fillPositions(), and MultiApp::position().

◆ _positions_objs

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

protectedinherited

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

Definition at line 490 of file MultiApp.h.

Referenced by MultiApp::fillPositions(), and MultiApp::position().

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _rank_config

LocalRankConfig MultiApp::_rank_config

protectedinherited

The app configuration resulting from calling init.

Definition at line 614 of file MultiApp.h.

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

◆ _reset_apps

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

protectedinherited

The apps to be reset.

Definition at line 571 of file MultiApp.h.

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

◆ _reset_happened

std::vector<bool> MultiApp::_reset_happened

protectedinherited

Whether or not apps have been reset at each time.

Definition at line 574 of file MultiApp.h.

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

◆ _reset_timer

const PerfID MultiApp::_reset_timer

protectedinherited

Definition at line 630 of file MultiApp.h.

Referenced by MultiApp::resetApp().

◆ _reset_times

std::vector<Real> MultiApp::_reset_times

protectedinherited

The times at which to reset apps.

Definition at line 568 of file MultiApp.h.

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

◆ _restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 227 of file Restartable.h.

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

◆ _restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 236 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 230 of file Restartable.h.

Referenced by Restartable::restartableName().

◆ _restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 233 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _restore_timer

const PerfID MultiApp::_restore_timer

protectedinherited

Definition at line 629 of file MultiApp.h.

Referenced by MultiApp::restore().

◆ _run_in_position

const bool MultiApp::_run_in_position

protectedinherited

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

Definition at line 620 of file MultiApp.h.

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

◆ _solve_step_timer

const PerfID MultiApp::_solve_step_timer

protectedinherited

Timers.

Definition at line 626 of file MultiApp.h.

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

◆ _sub_app_backups

SubAppBackups& MultiApp::_sub_app_backups

protectedinherited

The cached subapp backups (passed from the parent app)

Definition at line 623 of file MultiApp.h.

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

◆ _total_num_apps

unsigned int MultiApp::_total_num_apps

protectedinherited

The total number of apps to simulate.

Definition at line 511 of file MultiApp.h.

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

◆ _type

const std::string MooseBase::_type

protectedinherited

The type of this class.

Definition at line 87 of file MooseBase.h.

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

◆ _use_positions

const bool MultiApp::_use_positions

protectedinherited

Toggle use of "positions".

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

Definition at line 496 of file MultiApp.h.

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

◆ _wait_for_first_app_init

const bool& MultiApp::_wait_for_first_app_init

protectedinherited

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

Definition at line 502 of file MultiApp.h.

Referenced by MultiApp::createApps().

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

include/multiapps/QuadraturePointMultiApp.h
src/multiapps/QuadraturePointMultiApp.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ QuadraturePointMultiApp()

Member Function Documentation

◆ addAssociatedTransfer()

◆ appPostprocessorValue()

◆ appProblem()

◆ appProblemBase()

◆ appTransferVector()

◆ appUserObjectBase()

◆ backup()

◆ blockIDs()

◆ blockRestricted()

◆ blocks()

◆ blocksMaxDimension()

◆ buildComm()

◆ callMooseError()

◆ checkVariable()

◆ cliArgs()

◆ comm()

◆ computeDT()

◆ connectControllableParams()

◆ createApp()

◆ createApps()

◆ createLocalApp()

◆ customSetup()

◆ declareManagedRestartableDataWithContext()

◆ declareRecoverableData()

◆ declareRestartableData()

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ enabled()

◆ errorPrefix()

◆ fillPositions()

◆ finalize()

◆ finishStep()

◆ firstLocalApp()

◆ getBlockCoordSystem()

◆ getBoundingBox()

◆ getCheckedPointerParam()

◆ getCommandLineArgs()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getExecuteOnEnum()

◆ getExecutioner()

◆ getMooseApp()

◆ getMultiAppName()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getRenamedParam()

◆ getRestartableData()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ globalAppToLocal()

◆ hasApp()

◆ hasBlockMaterialProperty()

◆ hasBlockMaterialPropertyHelper()

◆ hasBlocks() [1/6]

◆ hasBlocks() [2/6]

◆ hasBlocks() [3/6]

◆ hasBlocks() [4/6]

◆ hasBlocks() [5/6]

◆ hasBlocks() [6/6]

◆ hasLocalApp()

◆ incrementTStep()

◆ init() [1/2]

◆ init() [2/2]

◆ initializeBlockRestrictable()

◆ initialSetup()