MooseApp Class Reference

Base class for MOOSE-based applications. More...

#include <MooseApp.h>

Inheritance diagram for MooseApp:

Classes
struct	DynamicLibraryInfo
struct	FixedPointConfig
	Stores configuration options relating to the fixed-point solving capability. More...
struct	InterfaceRegistryObjects
struct	InterfaceRegistryObjectsBase

Public Member Functions
virtual	~MooseApp ()
TheWarehouse &	theWarehouse ()
virtual std::string	getPrintableName () const
	Get printable name of the application. More...
virtual std::string	appBinaryName () const
InputParameters &	parameters ()
	Get the parameters of the object. More...
const RankMap &	rankMap ()
	The RankMap is a useful object for determining how the processes are laid out on the physical nodes of the cluster. More...
PerfGraph &	perfGraph ()
	Get the PerfGraph for this app. More...
SolutionInvalidity &	solutionInvalidity ()
	Get the SolutionInvalidity for this app. 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...
bool	isParamValid (const std::string &name) const
bool	isParamSetByUser (const std::string &nm) const
virtual void	run ()
	Run the application. More...
std::string	getFrameworkVersion () const
	Returns the framework version. More...
virtual std::string	getVersion () const
	Returns the current version of the framework or application (default: framework version). More...
std::string	getPrintableVersion () const
	Non-virtual method for printing out the version string in a consistent format. More...
virtual void	setupOptions ()
	Setup options based on InputParameters. More...
ActionWarehouse &	actionWarehouse ()
	Return a writable reference to the ActionWarehouse associated with this app. More...
const ActionWarehouse &	actionWarehouse () const
	Return a const reference to the ActionWarehouse associated with this app. More...
Moose::Builder &	builder ()
	Returns a writable reference to the builder. More...
Syntax &	syntax ()
	Returns a writable reference to the syntax object. More...
const std::vector< std::string > &	getInputFileNames () const
const std::string &	getLastInputFileName () const
void	setOutputFileBase (const std::string &output_file_base)
	Override the selection of the output file base name. More...
std::string	getOutputFileBase (bool for_non_moose_build_output=false) const
	Get the output file base name. More...
void	setOutputPosition (const Point &p)
	Tell the app to output in a specific position. More...
std::list< std::string >	getCheckpointDirectories () const
	Get all checkpoint directories. More...
std::list< std::string >	getCheckpointFiles () const
	Extract all possible checkpoint file names. More...
bool	hasOutputPosition () const
	Whether or not an output position has been set. More...
Point	getOutputPosition () const
	Get the output position. More...
void	setStartTime (Real time)
	Set the starting time for the simulation. More...
bool	hasStartTime () const
Real	getStartTime () const
void	setGlobalTimeOffset (Real offset)
	Each App has it's own local time. More...
Real	getGlobalTimeOffset () const
	Each App has it's own local time. More...
std::string	getFileName (bool stripLeadingPath=true) const
	Return the primary (first) filename that was parsed Note: When stripLeadingPath is false, this function returns the same name as getInputFileName() method when the input file is not a link. More...
void	setErrorOverridden ()
	Set a flag so that the parser will throw an error if overridden parameters are detected. More...
void	disableCheckUnusedFlag ()
	Removes warnings and error checks for unrecognized variables in the input file. More...
Executioner *	getExecutioner () const
	Retrieve the Executioner for this App. More...
Executor *	getExecutor () const
NullExecutor *	getNullExecutor () const
bool	useExecutor () const
FEProblemBase &	feProblem () const
void	setExecutioner (std::shared_ptr< Executioner > &&executioner)
	Set the Executioner for this App. More...
void	setExecutor (std::shared_ptr< Executor > &&executor)
void	addExecutor (const std::string &type, const std::string &name, const InputParameters &params)
void	addExecutorParams (const std::string &type, const std::string &name, const InputParameters &params)
	Adds the parameters for an Executor to the list of parameters. More...
Parser &	parser ()
void	createExecutors ()
	After adding all of the Executor Params - this function will actually cause all of them to be built. More...
Executor &	getExecutor (const std::string &name, bool fail_if_not_found=true)
	Get an Executor. More...
FixedPointConfig &	fixedPointConfig ()
	This info is stored here because we need a "globalish" place to put it in order to allow communication between a multiapp and solver-specific internals (i.e. More...
bool &	useNonlinear ()
	Returns a writable Boolean indicating whether this app will use a Nonlinear or Eigen System. More...
bool &	useEigenvalue ()
	Returns a writable Boolean indicating whether this app will use an eigenvalue executioner. More...
Factory &	getFactory ()
	Retrieve a writable reference to the Factory associated with this App. More...
ActionFactory &	getActionFactory ()
	Retrieve a writable reference to the ActionFactory associated with this App. More...
processor_id_type	processor_id () const
	Returns the MPI processor ID of the current processor. More...
std::shared_ptr< CommandLine >	commandLine () const
	Get the command line. More...
void	setExodusFileRestart (bool flag)
	Set the flag to indicate whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh. More...
bool	getExodusFileRestart () const
	Whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh. More...
void	setExReaderForRestart (std::shared_ptr< ExodusII_IO > &&exreader)
	Set the Exodus reader to restart variables from an Exodus mesh file. More...
ExodusII_IO *	getExReaderForRestart () const
	Get the Exodus reader to restart variables from an Exodus mesh file. More...
virtual void	runInputFile ()
	Actually build everything in the input file. More...
virtual void	executeExecutioner ()
	Execute the Executioner that was built. More...
bool	getDistributedMeshOnCommandLine () const
	Returns true if the user specified –distributed-mesh (or –parallel-mesh, for backwards compatibility) on the command line and false otherwise. More...
bool	isRecovering () const
	Whether or not this is a "recover" calculation. More...
bool	isRestarting () const
	Whether or not this is a "restart" calculation. More...
bool	isSplitMesh () const
	Whether or not this is a split mesh operation. More...
void	setRestartRecoverFileBase (const std::string &file_base)
	mutator for recover_base (set by RecoverBaseAction) More...
bool	testCheckpointHalfTransient () const
	Whether or not this simulation should only run half its transient (useful for testing recovery) More...
void	setOutputFileNumbers (const std::map< std::string, unsigned int > &numbers)
	Store a map of outputter names and file numbers The MultiApp system requires this to get the file numbering to propagate down through the Multiapps. More...
const std::map< std::string, unsigned int > &	getOutputFileNumbers () const
	Store a map of outputter names and file numbers The MultiApp system requires this to get the file numbering to propogate down through the multiapps. More...
OutputWarehouse &	getOutputWarehouse ()
	Get the OutputWarehouse objects. More...
const SystemInfo *	getSystemInfo () const
	Get SystemInfo object. More...
std::string	appNameToLibName (const std::string &app_name) const
	Converts an application name to a library name: Examples: AnimalApp -> libanimal-oprof.la (assuming METHOD=oprof) ThreeWordAnimalApp -> libthree_word_animal-dbg.la (assuming METHOD=dbg) More...
std::string	libNameToAppName (const std::string &library_name) const
	Converts a library name to an application name: More...
std::set< std::string >	getLoadedLibraryPaths () const
	Return the paths of loaded libraries. More...
std::set< std::string >	getLibrarySearchPaths (const std::string &library_path_from_param) const
	Return the paths searched by MOOSE when loading libraries. More...
InputParameterWarehouse &	getInputParameterWarehouse ()
	Get the InputParameterWarehouse for MooseObjects. More...
RestartableDataValue &	registerRestartableData (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
RestartableDataValue &	registerRestartableData (const std::string &name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
bool	hasRestartableMetaData (const std::string &name, const RestartableDataMapName &metaname) const
RestartableDataValue &	getRestartableMetaData (const std::string &name, const RestartableDataMapName &metaname, THREAD_ID tid)
void	possiblyLoadRestartableMetaData (const RestartableDataMapName &name, const std::filesystem::path &folder_base)
	Loads the restartable meta data for name if it is available with the folder base folder_base. More...
void	loadRestartableMetaData (const std::filesystem::path &folder_base)
	Loads all available restartable meta data if it is available with the folder base folder_base. More...
std::vector< std::filesystem::path >	writeRestartableMetaData (const RestartableDataMapName &name, const std::filesystem::path &folder_base)
	Writes the restartable meta data for name with a folder base of folder_base. More...
std::vector< std::filesystem::path >	writeRestartableMetaData (const std::filesystem::path &folder_base)
	Writes all available restartable meta data with a file base of file_base. More...
RestartableDataMap &	getRestartableDataMap (const RestartableDataMapName &name)
	Return a reference to restartable data for the specific type flag. More...
bool	hasRestartableDataMap (const RestartableDataMapName &name) const
void	registerRestartableDataMapName (const RestartableDataMapName &name, std::string suffix="")
	Reserve a location for storing custom RestartableDataMap objects. More...
const std::string &	getRestartableDataMapName (const RestartableDataMapName &name) const
const DataNames &	getRecoverableData () const
	Return a reference to the recoverable data object. More...
std::vector< std::filesystem::path >	backup (const std::filesystem::path &folder_base)
	Backs up the application to the folder folder_base. More...
std::unique_ptr< Backup >	backup ()
	Backs up the application memory in a Backup. More...
virtual void	preBackup ()
	Insertion point for other apps that is called before backup() More...
void	restore (const std::filesystem::path &folder_base, const bool for_restart)
	Restore an application from file. More...
void	restore (std::unique_ptr< Backup > backup, const bool for_restart)
	Restore an application from the backup backup. More...
virtual void	postRestore (const bool)
	Insertion point for other apps that is called after restore() More...
void	restoreFromInitialBackup (const bool for_restart)
	Restores from a "initial" backup, that is, one set in _initial_backup. More...
std::unique_ptr< Backup >	finalizeRestore ()
	Finalizes (closes) the restoration process done in restore(). More...
virtual std::string	header () const
	Returns a string to be printed at the beginning of a simulation. More...
unsigned int	multiAppLevel () const
	The MultiApp Level. More...
unsigned int	multiAppNumber () const
	The MultiApp number. More...
bool	isUltimateMaster () const
	Whether or not this app is the ultimate master app. More...
const MooseMesh *	masterMesh () const
	Returns a pointer to the master mesh. More...
const MooseMesh *	masterDisplacedMesh () const
	Returns a pointer to the master displaced mesh. More...
MeshGeneratorSystem &	getMeshGeneratorSystem ()
	Gets the system that manages the MeshGenerators. More...
void	addMeshGenerator (const std::string &type, const std::string &name, const InputParameters &params)
	Add a mesh generator that will act on the meshes in the system. More...
bool	hasMeshGenerator (const MeshGeneratorName &name) const
const MeshGenerator &	getMeshGenerator (const std::string &name) const
std::unique_ptr< MeshBase >	getMeshGeneratorMesh ()
std::vector< std::string >	getMeshGeneratorNames () const
const MeshGenerator &	appendMeshGenerator (const std::string &type, const std::string &name, InputParameters params)
	Append a mesh generator that will act on the final mesh generator in the system. More...
virtual bool	constructingMeshGenerators () const
	Whether this app is constructing mesh generators. More...
bool	checkInput () const
	Returns whether the Application is running in check input mode. More...
bool	getFPTrapFlag () const
	Returns whether FPE trapping is turned on (either because of debug or user requested) More...
bool	hasRelationshipManager (const std::string &name) const
	Returns a Boolean indicating whether a RelationshipManater exists with the same name. More...
bool	addRelationshipManager (std::shared_ptr< RelationshipManager > relationship_manager)
	Transfers ownership of a RelationshipManager to the application for lifetime management. More...
std::filesystem::path	restartFolderBase (const std::filesystem::path &folder_base) const
	The file suffix for restartable data. More...
const hit::Node *	getCurrentActionHitNode () const
void	attachRelationshipManagers (Moose::RelationshipManagerType rm_type, bool attach_geometric_rm_final=false)
	Attach the relationship managers of the given type Note: Geometric relationship managers that are supposed to be attached late will be attached when Algebraic are attached. More...
void	attachRelationshipManagers (MeshBase &mesh, MooseMesh &moose_mesh)
	Attach geometric relationship managers to the given MeshBase object. More...
const std::vector< std::shared_ptr< RelationshipManager > > &	getReleationshipManagers ()
	Retrieve the relationship managers. More...
std::vector< std::pair< std::string, std::string > >	getRelationshipManagerInfo () const
	Returns the Relationship managers info suitable for printing. More...
const ExecFlagEnum &	getExecuteOnEnum () const
	Return the app level ExecFlagEnum, this contains all the available flags for the app. More...
bool	hasInitialBackup () const
bool	defaultAutomaticScaling () const
	Whether to enable automatic scaling by default. More...
const std::shared_ptr< Parallel::Communicator >	getCommunicator () const
const std::set< std::shared_ptr< RelationshipManager > > &	relationshipManagers () const
	Return the container of relationship managers. More...
void	checkMetaDataIntegrity () const
	Function to check the integrity of the restartable meta data structure. More...
virtual bool	errorOnJacobianNonzeroReallocation () const
	Whether this application should by default error on Jacobian nonzero reallocations. More...
template<class T >
void	registerInterfaceObject (T &interface)
	Registers an interface object for accessing with getInterfaceObjects. More...
template<class T >
const std::vector< T * > &	getInterfaceObjects () const
	Gets the registered interface objects for a given interface. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () 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...
template<typename T >
const T &	getParam (const std::string &name)
	Retrieve a parameter for the object. More...
template<typename T >
const T &	getParam (const std::string &name) const
bool	hasRestartRecoverFileBase () const
	Return true if the recovery file base is set. More...
bool	hasRecoverFileBase () const
std::string	getRestartRecoverFileBase () const
	The file_base for the recovery file. More...
std::string	getRecoverFileBase () const
void	dynamicAllRegistration (const std::string &app_name, Factory *factory, ActionFactory *action_factory, Syntax *syntax, std::string library_path, const std::string &library_name)
	Thes methods are called to register applications or objects on demand. More...
void	dynamicAppRegistration (const std::string &app_name, std::string library_path, const std::string &library_name, bool lib_load_deps)
const std::vector< RestartableDataMap > &	getRestartableData () const
	Return reference to the restartable data object. More...
std::vector< RestartableDataMap > &	getRestartableData ()
void	setRestart (bool value)
	Sets the restart/recover flags. More...
void	setRecover (bool value)
auto	getRestartableDataMapBegin ()
	Iterator based access to the extra RestartableDataMap objects; see Checkpoint.C for use case. More...
auto	getRestartableDataMapEnd ()

Static Public Member Functions
static InputParameters	validParams ()
static const std::string &	checkpointSuffix ()
	The file suffix for the checkpoint mesh. More...
static std::filesystem::path	metaDataFolderBase (const std::filesystem::path &folder_base, const std::string &map_suffix)
	The file suffix for meta data (header and data) More...
static void	addAppParam (InputParameters &params)

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

Static Public Attributes
static const RestartableDataMapName	MESH_META_DATA = "MeshMetaData"
static const std::string	MESH_META_DATA_SUFFIX = "mesh"

Protected Types
enum	UNUSED_CHECK { OFF, WARN_UNUSED, ERROR_UNUSED }
	Indicates whether warnings, errors, or no output is displayed when unused parameters are detected. More...

Protected Member Functions
void	dynamicRegistration (const Parameters &params)
	Helper method for dynamic loading of objects. More...
void	loadLibraryAndDependencies (const std::string &library_filename, const Parameters &params, bool load_dependencies=true)
	Recursively loads libraries and dependencies in the proper order to fully register a MOOSE application that may have several dependencies. More...
	MooseApp (InputParameters parameters)
	Constructor is protected so that this object is constructed through the AppFactory object. More...
void	registerRestartableNameWithFilter (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	NOTE: This is an internal function meant for MOOSE use only! More...
void	errorCheck ()
	Runs post-initialization error checking that cannot be run correctly unless the simulation has been fully set up and initialized. 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

Protected Attributes
const std::string	_name
	The name of this object. More...
InputParameters	_pars
	Parameters of this object. More...
const std::string	_type
	The string representation of the type of this object as registered (see registerApp(AppName)) More...
const std::shared_ptr< Parallel::Communicator >	_comm
	The MPI communicator this App is going to use. More...
std::string	_output_file_base
	The output file basename. More...
bool	_file_base_set_by_user
	Whether or not file base is set through input or setOutputFileBase by MultiApp. More...
bool	_output_position_set
	Whether or not an output position has been set for this app. More...
Point	_output_position
	The output position. More...
bool	_start_time_set
	Whether or not an start time has been set. More...
Real	_start_time
	The time at which to start the simulation. More...
Real	_global_time_offset
	Offset of the local App time to the "global" problem time. More...
std::shared_ptr< CommandLine >	_command_line
	Command line object. More...
Syntax	_syntax
	Syntax of the input file. More...
std::unique_ptr< InputParameterWarehouse >	_input_parameter_warehouse
	Input parameter storage structure; unique_ptr so we can control its destruction order. More...
ActionFactory	_action_factory
	The Factory responsible for building Actions. More...
ActionWarehouse	_action_warehouse
	Where built actions are stored. More...
OutputWarehouse	_output_warehouse
	OutputWarehouse object for this App. More...
const std::shared_ptr< Parser >	_parser
	Parser for parsing the input file. More...
Moose::Builder	_builder
	Builder for building app related parser tree. More...
std::vector< RestartableDataMap >	_restartable_data
	Where the restartable data is held (indexed on tid) More...
DataNames	_recoverable_data_names
	Data names that will only be read from the restart file during RECOVERY. More...
PerfGraph &	_perf_graph
	The PerfGraph object for this application (recoverable) More...
SolutionInvalidity &	_solution_invalidity
	The SolutionInvalidity object for this application. More...
const RankMap	_rank_map
	The RankMap is a useful object for determining how the processes are laid out on the physical hardware. More...
std::shared_ptr< Executioner >	_executioner
	Pointer to the executioner of this run (typically build by actions) More...
std::shared_ptr< Executor >	_executor
	Pointer to the Executor of this run. More...
std::map< std::string, std::shared_ptr< Executor > >	_executors
	Pointers to all of the Executors for this run. More...
std::unordered_map< std::string, std::pair< std::string, std::unique_ptr< InputParameters > > >	_executor_params
	Used in building the Executors Maps the name of the Executor block to the <type, params> More...
FixedPointConfig	_fixed_point_config
	Multiapp-related fixed point algorithm configuration details primarily intended to be passed to and used by the executioner/executor system. More...
const bool	_use_executor
	Indicates whether we are operating in the new/experimental executor mode instead of using the legacy executioner system. More...
std::shared_ptr< NullExecutor >	_null_executor
	Used to return an executor that does nothing. More...
bool	_use_nonlinear
	Boolean to indicate whether to use a Nonlinear or EigenSystem (inspected by actions) More...
bool	_use_eigen_value
	Boolean to indicate whether to use an eigenvalue executioner. More...
std::unique_ptr< SystemInfo >	_sys_info
	System Information. More...
enum MooseApp::UNUSED_CHECK	_enable_unused_check
Factory	_factory
bool	_error_overridden
	Indicates whether warnings or errors are displayed when overridden parameters are detected. More...
bool	_ready_to_exit
bool	_initial_from_file
	This variable indicates when a request has been made to restart from an Exodus file. More...
std::shared_ptr< ExodusII_IO >	_ex_reader
	The Exodus reader when _initial_from_file is set to true. More...
bool	_distributed_mesh_on_command_line
	This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh. More...
bool	_recover
	Whether or not this is a recovery run. More...
bool	_restart
	Whether or not this is a restart run. More...
bool	_split_mesh
	Whether or not we are performing a split mesh operation (–split-mesh) More...
const bool	_use_split
	Whether or not we are using a (pre-)split mesh (automatically DistributedMesh) More...
bool	_trap_fpe
	Whether or not FPE trapping should be turned on. More...
std::string	_restart_recover_base
	The base name to restart/recover from. If blank then we will find the newest checkpoint file. More...
bool	_test_checkpoint_half_transient
	Whether or not this simulation should only run half its transient (useful for testing recovery) More...
std::map< std::string, unsigned int >	_output_file_numbers
	Map of outputer name and file number (used by MultiApps to propagate file numbers down through the multiapps) More...
bool	_check_input
	true if we want to just check the input file More...
std::set< std::shared_ptr< RelationshipManager > >	_relationship_managers
	The relationship managers that have been added. More...
std::map< Moose::RelationshipManagerType, std::set< const RelationshipManager * > >	_attached_relationship_managers
	The relationship managers that have been attached (type -> RMs) More...
std::unordered_map< RelationshipManager *, std::shared_ptr< GhostingFunctor > >	_undisp_to_disp_rms
	A map from undisplaced relationship managers to their displaced clone (stored as the base GhostingFunctor). More...
std::unordered_map< std::string, DynamicLibraryInfo >	_lib_handles
	The library archive (name only), registration method and the handle to the method. 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 Parallel::Communicator &	_communicator
MooseApp &	_app
	The MOOSE application this is associated with. More...

Private Types
enum	RegistrationType { APPLICATION, REGALL }
	Enumeration for holding the valid types of dynamic registrations allowed. More...

Private Member Functions
void	recursivelyCreateExecutors (const std::string &current_executor_name, std::list< std::string > &possible_roots, std::list< std::string > &current_branch)
	Internal function used to recursively create the executor objects. More...
void	removeRelationshipManager (std::shared_ptr< RelationshipManager > relationship_manager)
	Purge this relationship manager from meshes and DofMaps and finally from us. More...
void	createMinimalApp ()
	Method for creating the minimum required actions for an application (no input file) More...
void	setCheckUnusedFlag (bool warn_is_error=false)
	Set a flag so that the parser will either warn or error when unused variables are seen after parsing is complete. More...
bool	hasRMClone (const RelationshipManager &template_rm, const MeshBase &mesh) const
RelationshipManager &	getRMClone (const RelationshipManager &template_rm, const MeshBase &mesh) const
	Return the relationship manager clone originally created from the provided template relationship manager and mesh. More...
RelationshipManager &	createRMFromTemplateAndInit (const RelationshipManager &template_rm, MooseMesh &moose_mesh, MeshBase &mesh, const DofMap *dof_map=nullptr)
	Take an input relationship manager, clone it, and then initialize it with provided mesh and optional dof_map. More...
PerfGraph &	createRecoverablePerfGraph ()
	Creates a recoverable PerfGraph. More...
SolutionInvalidity &	createRecoverableSolutionInvalidity ()
	Creates a recoverable SolutionInvalidity. More...
bool	showInputs () const
	Prints a message showing the installable inputs for a given application (if getInstallableInputs has been overridden for an application). More...
virtual std::string	getInstallableInputs () const
	Method to retrieve the installable inputs from a given applications <app>Revision.h file. More...
bool	copyInputs () const
	Handles the copy_inputs input parameter logic: Checks to see whether the passed argument is valid (a readable installed directory) and recursively copies those files into a read/writable location for the user. More...
bool	runInputs () const
	Handles the run input parameter logic: Checks to see whether a directory exists in user space and launches the TestHarness to process the given directory. More...

Private Attributes
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > >	_restartable_meta_data
	General storage for custom RestartableData that can be added to from outside applications. More...
std::unique_ptr< TheWarehouse >	_the_warehouse
	The combined warehouse for storing any MooseObject based object. More...
unsigned int	_multiapp_level
	Level of multiapp, the master is level 0. This used by the Console to indent output. More...
unsigned int	_multiapp_number
	Numbering in all the sub-apps on the same level. More...
const MooseMesh *const	_master_mesh
	The mesh from master app. More...
const MooseMesh *const	_master_displaced_mesh
	The displaced mesh from master app. More...
MeshGeneratorSystem	_mesh_generator_system
	The system that manages the MeshGenerators. More...
RestartableDataReader	_rd_reader
const ExecFlagEnum	_execute_flags
	Execution flags for this App. More...
std::streambuf *	_output_buffer_cache
	Cache output buffer so the language server can turn it off then back on. More...
const bool	_automatic_automatic_scaling
	Whether to turn on automatic scaling by default. More...
bool	_cpu_profiling = false
	CPU profiling. More...
bool	_heap_profiling = false
	Memory profiling. More...
std::map< const RelationshipManager *, std::map< const MeshBase *, std::unique_ptr< RelationshipManager > > >	_template_to_clones
	Map from a template relationship manager to a map in which the key-value pairs represent the MeshBase object and the clone of the template relationship manager, e.g. More...
std::map< std::type_index, std::unique_ptr< InterfaceRegistryObjectsBase > >	_interface_registry
	Registration for interface objects. More...
std::unique_ptr< Backup > *const	_initial_backup
	The backup for use in initial setup; this will get set from the _initial_backup input parameter that typically gets set from a MultiApp that has a backup This is a pointer to a pointer because at the time of construction of the app, the backup will not be filled yet. More...

Friends
class	FEProblemBase
class	Restartable
class	SubProblem

Detailed Description

Base class for MOOSE-based applications.

This generic class for application provides:

• parsing command line arguments,
• parsing an input file,
• executing the simulation

Each application should register its own objects and register its own special syntax

Definition at line 73 of file MooseApp.h.

Member Enumeration Documentation

RegistrationType

enum MooseApp::RegistrationType

private

Enumeration for holding the valid types of dynamic registrations allowed.

Enumerator
APPLICATION
REGALL

Definition at line 1395 of file MooseApp.h.

  {
    APPLICATION,
    REGALL
  };

UNUSED_CHECK

enum MooseApp::UNUSED_CHECK

protected

Indicates whether warnings, errors, or no output is displayed when unused parameters are detected.

Enumerator
OFF
WARN_UNUSED
ERROR_UNUSED

Definition at line 1198 of file MooseApp.h.

  {
    OFF,
    WARN_UNUSED,
    ERROR_UNUSED
  } _enable_unused_check;

Constructor & Destructor Documentation

~MooseApp()

MooseApp::~MooseApp ( )

virtual

Definition at line 638 of file MooseApp.C.

{
#ifdef HAVE_GPERFTOOLS
  // CPU profiling stop
  if (_cpu_profiling)
    ProfilerStop();
  // Heap profiling stop
  if (_heap_profiling)
    HeapProfilerStop();
#endif
  _action_warehouse.clear();
  _executioner.reset();
  _the_warehouse.reset();

  // Don't wait for implicit destruction of input parameter storage
  _input_parameter_warehouse.reset();

  // This is dirty, but I don't know what else to do. Obviously, others
  // have had similar problems if you look above. In specific, the
  // dlclose below on macs is destructing some data that does not
  // belong to it in garbage collection. So... don't even give
  // dlclose an option
  _restartable_data.clear();

#ifdef LIBMESH_HAVE_DLOPEN
  // Close any open dynamic libraries
  for (const auto & lib_pair : _lib_handles)
    dlclose(lib_pair.second.library_handle);
#endif
}

MooseApp()

MooseApp::MooseApp ( InputParameters  parameters )

protected

Constructor is protected so that this object is constructed through the AppFactory object.

Definition at line 365 of file MooseApp.C.

  : ConsoleStreamInterface(*this),
    PerfGraphInterface(*this, "MooseApp"),
    ParallelObject(*parameters.get<std::shared_ptr<Parallel::Communicator>>(
        "_comm")), // Can't call getParam() before pars is set
    MooseBase(parameters.get<std::string>("_type"),
              parameters.get<std::string>("_app_name"),
              *this,
              _pars),
    _pars(parameters),
    _comm(getParam<std::shared_ptr<Parallel::Communicator>>("_comm")),
    _file_base_set_by_user(false),
    _output_position_set(false),
    _start_time_set(false),
    _start_time(0.0),
    _global_time_offset(0.0),
    _input_parameter_warehouse(std::make_unique<InputParameterWarehouse>()),
    _action_factory(*this),
    _action_warehouse(*this, _syntax, _action_factory),
    _output_warehouse(*this),
    _parser(parameters.get<std::shared_ptr<Parser>>("_parser")),
    _builder(*this, _action_warehouse, _parser),
    _restartable_data(libMesh::n_threads()),
    _perf_graph(createRecoverablePerfGraph()),
    _solution_invalidity(createRecoverableSolutionInvalidity()),
    _rank_map(*_comm, _perf_graph),
    _use_executor(parameters.get<bool>("use_executor")),
    _null_executor(NULL),
    _use_nonlinear(true),
    _use_eigen_value(false),
    _enable_unused_check(ERROR_UNUSED),
    _factory(*this),
    _error_overridden(false),
    _ready_to_exit(false),
    _initial_from_file(false),
    _distributed_mesh_on_command_line(false),
    _recover(false),
    _restart(false),
    _split_mesh(false),
    _use_split(parameters.get<bool>("use_split")),
#ifdef DEBUG
    _trap_fpe(true),
#else
    _trap_fpe(false),
#endif
    _test_checkpoint_half_transient(false),
    _check_input(getParam<bool>("check_input")),
    _multiapp_level(
        isParamValid("_multiapp_level") ? parameters.get<unsigned int>("_multiapp_level") : 0),
    _multiapp_number(
        isParamValid("_multiapp_number") ? parameters.get<unsigned int>("_multiapp_number") : 0),
    _master_mesh(isParamValid("_master_mesh") ? parameters.get<const MooseMesh *>("_master_mesh")
                                              : nullptr),
    _master_displaced_mesh(isParamValid("_master_displaced_mesh")
                               ? parameters.get<const MooseMesh *>("_master_displaced_mesh")
                               : nullptr),
    _mesh_generator_system(*this),
    _rd_reader(*this, _restartable_data),
    _execute_flags(moose::internal::ExecFlagRegistry::getExecFlagRegistry().getFlags()),
    _output_buffer_cache(nullptr),
    _automatic_automatic_scaling(getParam<bool>("automatic_automatic_scaling")),
    _initial_backup(getParam<std::unique_ptr<Backup> *>("_initial_backup"))
{
  // Set the TIMPI sync type via --timpi-sync
  const auto & timpi_sync = parameters.get<std::string>("timpi_sync");
  const_cast<Parallel::Communicator &>(comm()).sync_type(timpi_sync);

#ifdef HAVE_GPERFTOOLS
  if (isUltimateMaster())
  {
    bool has_cpu_profiling = false;
    bool has_heap_profiling = false;
    static std::string cpu_profile_file;
    static std::string heap_profile_file;

    // For CPU profiling, users need to have environment 'MOOSE_PROFILE_BASE'
    if (std::getenv("MOOSE_PROFILE_BASE"))
    {
      has_cpu_profiling = true;
      cpu_profile_file =
          std::getenv("MOOSE_PROFILE_BASE") + std::to_string(_comm->rank()) + ".prof";
      // create directory if needed
      auto name = MooseUtils::splitFileName(cpu_profile_file);
      if (!name.first.empty())
      {
        if (processor_id() == 0)
          MooseUtils::makedirs(name.first.c_str());
        _comm->barrier();
      }
    }

    // For Heap profiling, users need to have 'MOOSE_HEAP_BASE'
    if (std::getenv("MOOSE_HEAP_BASE"))
    {
      has_heap_profiling = true;
      heap_profile_file = std::getenv("MOOSE_HEAP_BASE") + std::to_string(_comm->rank());
      // create directory if needed
      auto name = MooseUtils::splitFileName(heap_profile_file);
      if (!name.first.empty())
      {
        if (processor_id() == 0)
          MooseUtils::makedirs(name.first.c_str());
        _comm->barrier();
      }
    }

    // turn on profiling only on selected ranks
    if (isParamValid("gperf_profiler_on"))
    {
      auto rankstr = getParam<std::string>("gperf_profiler_on");
      std::vector<processor_id_type> ranks;
      bool success = MooseUtils::tokenizeAndConvert(rankstr, ranks, ", ");
      if (!success)
        mooseError("Invalid argument for --gperf-profiler-on: '", rankstr, "'");
      for (auto & rank : ranks)
      {
        if (rank >= _comm->size())
          mooseError("Invalid argument for --gperf-profiler-on: ",
                     rank,
                     " is greater than or equal to ",
                     _comm->size());
        if (rank == _comm->rank())
        {
          _cpu_profiling = has_cpu_profiling;
          _heap_profiling = has_heap_profiling;
        }
      }
    }
    else
    {
      _cpu_profiling = has_cpu_profiling;
      _heap_profiling = has_heap_profiling;
    }

    if (_cpu_profiling)
      if (!ProfilerStart(cpu_profile_file.c_str()))
        mooseError("CPU profiler is not started properly");

    if (_heap_profiling)
    {
      HeapProfilerStart(heap_profile_file.c_str());
      if (!IsHeapProfilerRunning())
        mooseError("Heap profiler is not started properly");
    }
  }
#else
  if (std::getenv("MOOSE_PROFILE_BASE") || std::getenv("MOOSE_HEAP_BASE"))
    mooseError("gperftool is not available for CPU or heap profiling");
#endif

  // If this will be a language server then turn off output until that starts
  if (isParamValid("language_server"))
    _output_buffer_cache = Moose::out.rdbuf(nullptr);

  Registry::addKnownLabel(_type);
  Moose::registerAll(_factory, _action_factory, _syntax);

  _the_warehouse = std::make_unique<TheWarehouse>();
  _the_warehouse->registerAttribute<AttribMatrixTags>("matrix_tags", 0);
  _the_warehouse->registerAttribute<AttribVectorTags>("vector_tags", 0);
  _the_warehouse->registerAttribute<AttribExecOns>("exec_ons", 0);
  _the_warehouse->registerAttribute<AttribSubdomains>("subdomains", 0);
  _the_warehouse->registerAttribute<AttribBoundaries>("boundaries", 0);
  _the_warehouse->registerAttribute<AttribThread>("thread", 0);
  _the_warehouse->registerAttribute<AttribExecutionOrderGroup>("execution_order_group", 0);
  _the_warehouse->registerAttribute<AttribPreIC>("pre_ic", 0);
  _the_warehouse->registerAttribute<AttribPreAux>("pre_aux");
  _the_warehouse->registerAttribute<AttribPostAux>("post_aux");
  _the_warehouse->registerAttribute<AttribName>("name", "dummy");
  _the_warehouse->registerAttribute<AttribSystem>("system", "dummy");
  _the_warehouse->registerAttribute<AttribVar>("variable", -1);
  _the_warehouse->registerAttribute<AttribInterfaces>("interfaces", 0);
  _the_warehouse->registerAttribute<AttribSysNum>("sys_num", libMesh::invalid_uint);
  _the_warehouse->registerAttribute<AttribResidualObject>("residual_object");
  _the_warehouse->registerAttribute<AttribSorted>("sorted");
  _the_warehouse->registerAttribute<AttribDisplaced>("displaced", -1);

  if (isParamValid("_argc") && isParamValid("_argv"))
  {
    int argc = getParam<int>("_argc");
    char ** argv = getParam<char **>("_argv");

    _sys_info = std::make_unique<SystemInfo>(argc, argv);
  }
  if (isParamValid("_command_line"))
    _command_line = getParam<std::shared_ptr<CommandLine>>("_command_line");
  else
    mooseError("Valid CommandLine object required");

  if (_check_input && isParamValid("recover"))
    mooseError("Cannot run --check-input with --recover. Recover files might not exist");

  if (isParamValid("start_in_debugger") && _multiapp_level == 0)
  {
    auto command = getParam<std::string>("start_in_debugger");

    Moose::out << "Starting in debugger using: " << command << std::endl;

    auto hostname = MooseUtils::hostname();

    std::stringstream command_stream;

    // This will start XTerm and print out some info first... then run the debugger
    command_stream << "xterm -e \"echo 'Rank: " << processor_id() << "  Hostname: " << hostname
                   << "  PID: " << getpid() << "'; echo ''; ";

    // Figure out how to run the debugger
    if (command.find("lldb") != std::string::npos || command.find("gdb") != std::string::npos)
      command_stream << command << " -p " << getpid();
    else
      mooseError("Unknown debugger: ",
                 command,
                 "\nIf this is truly what you meant then contact moose-users to have a discussion "
                 "about adding your debugger.");

    // Finish up the command
    command_stream << "\""
                   << " & ";

    std::string command_string = command_stream.str();
    Moose::out << "Running: " << command_string << std::endl;

    int ret = std::system(command_string.c_str());
    libmesh_ignore(ret);

    // Sleep to allow time for the debugger to attach
    std::this_thread::sleep_for(std::chrono::seconds(10));
  }

  if (!parameters.isParamSetByAddParam("stop_for_debugger"))
  {
    Moose::out << "\nStopping for " << getParam<unsigned int>("stop_for_debugger")
               << " seconds to allow attachment from a debugger.\n";

    Moose::out << "\nAll of the processes you can connect to:\n";
    Moose::out << "rank - hostname - pid\n";

    auto hostname = MooseUtils::hostname();

    {
      // The 'false' turns off the serialization warning
      SerializerGuard sg(_communicator, false); // Guarantees that the processors print in order
      Moose::err << processor_id() << " - " << hostname << " - " << getpid() << "\n";
    }

    Moose::out << "\nWaiting...\n" << std::endl;

    // Sleep to allow time for the debugger to attach
    std::this_thread::sleep_for(std::chrono::seconds(getParam<unsigned int>("stop_for_debugger")));
  }

  if (_master_mesh && _multiapp_level == 0)
    mooseError("Mesh can be passed in only for sub-apps");

  if (_master_displaced_mesh && !_master_mesh)
    mooseError("_master_mesh should have been set when _master_displaced_mesh is set");

  // Data specifically associated with the mesh (meta-data) that will read from the restart
  // file early during the simulation setup so that they are available to Actions and other objects
  // that need them during the setup process. Most of the restartable data isn't made available
  // until all objects have been created and all Actions have been executed (i.e. initialSetup).
  registerRestartableDataMapName(MooseApp::MESH_META_DATA, MooseApp::MESH_META_DATA_SUFFIX);

  if (parameters.have_parameter<bool>("use_legacy_dirichlet_bc"))
    mooseDeprecated("The parameter 'use_legacy_dirichlet_bc' is no longer valid.\n\n",
                    "All Dirichlet boundary conditions are preset by default.\n\n",
                    "Remove said parameter in ",
                    name(),
                    " to remove this deprecation warning.");

  Moose::out << std::flush;
}

Member Function Documentation

actionWarehouse() [1/2]

ActionWarehouse& MooseApp::actionWarehouse ( )

inline

Return a writable reference to the ActionWarehouse associated with this app.

Definition at line 195 of file MooseApp.h.

Referenced by ElementIDOutputAction::act(), MeshOnlyAction::act(), SplitMeshAction::act(), MaterialOutputAction::act(), MeshGeneratorSystem::appendingMeshGenerators(), Console::Console(), Factory::create(), MeshGeneratorSystem::createAddedMeshGenerators(), MeshGeneratorSystem::createMeshGeneratorOrder(), MeshGeneratorSystem::dataDrivenError(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::dumpVariableHelper(), MeshGeneratorSystem::getMeshGeneratorOutput(), OutputWarehouse::getOutputNames(), ActionFactory::getValidParams(), Factory::initialize(), OutputWarehouse::mooseConsole(), Console::outputInput(), Exodus::outputInput(), PostprocessorInterface::postprocessorsAdded(), ReporterInterface::reportersAdded(), MeshGenerator::setMeshProperty(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

{ return _action_warehouse; }

actionWarehouse() [2/2]

const ActionWarehouse& MooseApp::actionWarehouse ( ) const

inline

Return a const reference to the ActionWarehouse associated with this app.

Definition at line 199 of file MooseApp.h.

{ return _action_warehouse; }

addAppParam()

void MooseApp::addAppParam ( InputParameters &  params )

static

Definition at line 85 of file MooseApp.C.

Referenced by AppFactory::createAppShared(), and validParams().

{
  params.addCommandLineParam<std::string>(
      "app_to_run",
      "--app <AppName>",
      "Specify the application that should be used to run the input file. This must match an "
      "application name registered to the application factory. Note that this option is "
      "case-sensitive.");
}

addExecutor()

void MooseApp::addExecutor	(	const std::string &	type,
		const std::string &	name,
		const InputParameters &	params
	)

Definition at line 1333 of file MooseApp.C.

Referenced by recursivelyCreateExecutors().

{
  std::shared_ptr<Executor> executor = _factory.create<Executor>(type, name, params);

  if (_executors.count(executor->name()) > 0)
    mooseError("an executor with name '", executor->name(), "' already exists");
  _executors[executor->name()] = executor;
}

addExecutorParams()

void MooseApp::addExecutorParams	(	const std::string &	type,
		const std::string &	name,
		const InputParameters &	params
	)

Adds the parameters for an Executor to the list of parameters.

This is done so that the Executors can be created in exactly the correct order.

Definition at line 1345 of file MooseApp.C.

Referenced by ReadExecutorParamsAction::act().

{
  _executor_params[name] = std::make_pair(type, std::make_unique<InputParameters>(params));
}

addMeshGenerator()

void MooseApp::addMeshGenerator ( const std::string &  type, const std::string &  name, const InputParameters &  params  )

inline

Add a mesh generator that will act on the meshes in the system.

Parameters

type	The type of MeshGenerator
name	The name of the MeshGenerator
params	The params used to construct the MeshGenerator

See MeshGeneratorSystem::addMeshGenerator()

Definition at line 831 of file MooseApp.h.

Referenced by AddMeshGeneratorAction::act(), and MeshGenerator::addMeshSubgenerator().

  {
    _mesh_generator_system.addMeshGenerator(type, name, params);
  }

addRelationshipManager()

bool MooseApp::addRelationshipManager

(

std::shared_ptr< RelationshipManager >

relationship_manager

)

Transfers ownership of a RelationshipManager to the application for lifetime management.

The RelationshipManager will NOT be duplicately added if an equivalent RelationshipManager is already active. In that case, it's possible that the object will be destroyed if the reference count drops to zero.

Definition at line 2349 of file MooseApp.C.

Referenced by AdaptivityAction::act(), SetAdaptivityOptionsAction::act(), AddPeriodicBCAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FVFluxKernel::adjustRMGhostLayers(), and FunctorSmootherTempl< T >::FunctorSmootherTempl().

{
  // We prefer to always add geometric RMs. There is no hurt to add RMs for replicated mesh
  // since MeshBase::delete_remote_elements{} is a no-op (empty) for replicated mesh.
  // The motivation here is that MooseMesh::_use_distributed_mesh may not be properly set
  // at the time we are adding geometric relationship managers. We deleted the following
  // old logic to add all geometric RMs regardless of there is a distributed mesh or not.
  // Otherwise, all geometric RMs will be improperly ignored for a distributed mesh generator.

  // if (!_action_warehouse.mesh()->isDistributedMesh() && !_split_mesh &&
  //    (relationship_manager->isType(Moose::RelationshipManagerType::GEOMETRIC) &&
  //     !(relationship_manager->isType(Moose::RelationshipManagerType::ALGEBRAIC) ||
  //       relationship_manager->isType(Moose::RelationshipManagerType::COUPLING))))
  //  return false;

  bool add = true;

  std::set<std::shared_ptr<RelationshipManager>> rms_to_erase;

  for (const auto & existing_rm : _relationship_managers)
  {
    if (*existing_rm >= *new_rm)
    {
      add = false;
      donateForWhom(*new_rm, *existing_rm);
      break;
    }
    // The new rm did not provide less or the same amount/type of ghosting as the existing rm, but
    // what about the other way around?
    else if (*new_rm >= *existing_rm)
      rms_to_erase.emplace(existing_rm);
  }

  if (add)
  {
    _relationship_managers.emplace(new_rm);
    for (const auto & rm_to_erase : rms_to_erase)
    {
      donateForWhom(*rm_to_erase, *new_rm);
      removeRelationshipManager(rm_to_erase);
    }
  }

  // Inform the caller whether the object was added or not
  return add;
}

appBinaryName()

virtual std::string MooseApp::appBinaryName ( ) const

inlinevirtual

Definition at line 109 of file MooseApp.h.

Referenced by copyInputs(), run(), and runInputs().

  {
    auto name = Moose::getExecutableName();
    name = name.substr(0, name.find_last_of("-"));
    if (name.find_first_of("/") != std::string::npos)
      name = name.substr(name.find_first_of("/") + 1, std::string::npos);
    return name;
  }

appendMeshGenerator()

const MeshGenerator& MooseApp::appendMeshGenerator ( const std::string &  type, const std::string &  name, InputParameters  params  )

inline

Append a mesh generator that will act on the final mesh generator in the system.

Parameters

type	The type of MeshGenerator
name	The name of the MeshGenerator
params	The params used to construct the MeshGenerator

See MeshGeneratorSystem::appendMeshGenerator()

Definition at line 882 of file MooseApp.h.

  {
    return _mesh_generator_system.appendMeshGenerator(type, name, params);
  }

appNameToLibName()

std::string MooseApp::appNameToLibName

(

const std::string &

app_name

)

const

Converts an application name to a library name: Examples: AnimalApp -> libanimal-oprof.la (assuming METHOD=oprof) ThreeWordAnimalApp -> libthree_word_animal-dbg.la (assuming METHOD=dbg)

Definition at line 1779 of file MooseApp.C.

Referenced by dynamicAllRegistration(), and dynamicAppRegistration().

{
  std::string library_name(app_name);

  // Strip off the App part (should always be the last 3 letters of the name)
  size_t pos = library_name.find("App");
  if (pos != library_name.length() - 3)
    mooseError("Invalid application name: ", library_name);
  library_name.erase(pos);

  // Now get rid of the camel case, prepend lib, and append the method and suffix
  return std::string("lib") + MooseUtils::camelCaseToUnderscore(library_name) + '-' +
         QUOTE(METHOD) + ".la";
}

attachRelationshipManagers() [1/2]

void MooseApp::attachRelationshipManagers	(	Moose::RelationshipManagerType	rm_type,
		bool	attach_geometric_rm_final = false
	)

Attach the relationship managers of the given type Note: Geometric relationship managers that are supposed to be attached late will be attached when Algebraic are attached.

Definition at line 2559 of file MooseApp.C.

Referenced by AddRelationshipManager::act(), CouplingFunctorCheckAction::act(), and MooseMesh::buildTypedMesh().

{
  for (auto & rm : _relationship_managers)
  {
    if (!rm->isType(rm_type))
      continue;

    // RM is already attached (this also handles the geometric early case)
    if (_attached_relationship_managers[rm_type].count(rm.get()))
      continue;

    if (rm_type == Moose::RelationshipManagerType::GEOMETRIC)
    {
      // The problem is not built yet - so the ActionWarehouse currently owns the mesh
      MooseMesh * const mesh = _action_warehouse.mesh().get();

      // "attach_geometric_rm_final = true" inidicate that it is the last chance to attach
      // geometric RMs. Therefore, we need to attach them.
      if (!rm->attachGeometricEarly() && !attach_geometric_rm_final)
        // Will attach them later (during algebraic). But also, we need to tell the mesh that we
        // shouldn't be deleting remote elements yet
        mesh->allowRemoteElementRemoval(false);
      else
      {
        MeshBase & undisp_mesh_base = mesh->getMesh();
        const DofMap * const undisp_sys_dof_map =
            _executioner ? &feProblem().getSolverSystem(0).dofMap() : nullptr;
        undisp_mesh_base.add_ghosting_functor(
            createRMFromTemplateAndInit(*rm, *mesh, undisp_mesh_base, undisp_sys_dof_map));

        // In the final stage, if there is a displaced mesh, we need to
        // clone ghosting functors for displacedMesh
        if (auto & disp_moose_mesh = _action_warehouse.displacedMesh();
            attach_geometric_rm_final && disp_moose_mesh)
        {
          MeshBase & disp_mesh_base = _action_warehouse.displacedMesh()->getMesh();
          const DofMap * disp_sys_dof_map = nullptr;
          if (_executioner && feProblem().getDisplacedProblem())
            disp_sys_dof_map = &feProblem().getDisplacedProblem()->solverSys(0).dofMap();
          disp_mesh_base.add_ghosting_functor(
              createRMFromTemplateAndInit(*rm, *disp_moose_mesh, disp_mesh_base, disp_sys_dof_map));
        }
        else if (_action_warehouse.displacedMesh())
          mooseError("The displaced mesh should not yet exist at the time that we are attaching "
                     "early geometric relationship managers.");

        // Mark this RM as attached
        mooseAssert(!_attached_relationship_managers[rm_type].count(rm.get()), "Already attached");
        _attached_relationship_managers[rm_type].insert(rm.get());
      }
    }
    else // rm_type is algebraic or coupling
    {
      if (!_executioner && !_executor)
        mooseError("We must have an executioner by now or else we do not have to data to add "
                   "algebraic or coupling functors to in MooseApp::attachRelationshipManagers");

      // Now we've built the problem, so we can use it
      auto & problem = feProblem();
      auto & undisp_moose_mesh = problem.mesh();
      auto & undisp_sys = feProblem().getSolverSystem(0);
      auto & undisp_sys_dof_map = undisp_sys.dofMap();
      auto & undisp_mesh = undisp_moose_mesh.getMesh();

      if (rm->useDisplacedMesh() && problem.getDisplacedProblem())
      {
        if (rm_type == Moose::RelationshipManagerType::COUPLING)
          // We actually need to add this to the FEProblemBase NonlinearSystemBase's DofMap
          // because the DisplacedProblem "nonlinear" DisplacedSystem doesn't have any matrices
          // for which to do coupling. It's actually horrifying to me that we are adding a
          // coupling functor, that is going to determine its couplings based on a displaced
          // MeshBase object, to a System associated with the undisplaced MeshBase object (there
          // is only ever one EquationSystems object per MeshBase object and visa versa). So here
          // I'm left with the choice of whether to pass in a MeshBase object that is *not* the
          // MeshBase object that will actually determine the couplings or to pass in the MeshBase
          // object that is inconsistent with the System DofMap that we are adding the coupling
          // functor for! Let's err on the side of *libMesh* consistency and pass properly paired
          // MeshBase-DofMap
          problem.addCouplingGhostingFunctor(
              createRMFromTemplateAndInit(*rm, undisp_moose_mesh, undisp_mesh, &undisp_sys_dof_map),
              /*to_mesh = */ false);

        else if (rm_type == Moose::RelationshipManagerType::ALGEBRAIC)
        {
          auto & displaced_problem = *problem.getDisplacedProblem();
          auto & disp_moose_mesh = displaced_problem.mesh();
          auto & disp_mesh = disp_moose_mesh.getMesh();
          const DofMap * const disp_nl_dof_map = &displaced_problem.solverSys(0).dofMap();
          displaced_problem.addAlgebraicGhostingFunctor(
              createRMFromTemplateAndInit(*rm, disp_moose_mesh, disp_mesh, disp_nl_dof_map),
              /*to_mesh = */ false);
        }
      }
      else // undisplaced
      {
        if (rm_type == Moose::RelationshipManagerType::COUPLING)
          problem.addCouplingGhostingFunctor(
              createRMFromTemplateAndInit(*rm, undisp_moose_mesh, undisp_mesh, &undisp_sys_dof_map),
              /*to_mesh = */ false);

        else if (rm_type == Moose::RelationshipManagerType::ALGEBRAIC)
          problem.addAlgebraicGhostingFunctor(
              createRMFromTemplateAndInit(*rm, undisp_moose_mesh, undisp_mesh, &undisp_sys_dof_map),
              /*to_mesh = */ false);
      }

      // Mark this RM as attached
      mooseAssert(!_attached_relationship_managers[rm_type].count(rm.get()), "Already attached");
      _attached_relationship_managers[rm_type].insert(rm.get());
    }
  }
}

attachRelationshipManagers() [2/2]

void MooseApp::attachRelationshipManagers	(	MeshBase &	mesh,
		MooseMesh &	moose_mesh
	)

Attach geometric relationship managers to the given MeshBase object.

This API is designed to work with MeshGenerators which are executed at the very beginning of a simulation. No attempt will be made to add relationship managers to a displaced mesh, because it doesn't exist yet.

Definition at line 2529 of file MooseApp.C.

{
  for (auto & rm : _relationship_managers)
  {
    if (rm->isType(Moose::RelationshipManagerType::GEOMETRIC))
    {
      if (rm->attachGeometricEarly())
        mesh.add_ghosting_functor(createRMFromTemplateAndInit(*rm, moose_mesh, mesh));
      else
      {
        // If we have a geometric ghosting functor that can't be attached early, then we have to
        // prevent the mesh from deleting remote elements
        moose_mesh.allowRemoteElementRemoval(false);

        if (const MeshBase * const moose_mesh_base = moose_mesh.getMeshPtr())
        {
          if (moose_mesh_base != &mesh)
            mooseError("The MooseMesh MeshBase and the MeshBase we're trying to attach "
                       "relationship managers to are different");
        }
        else
          // The MeshBase isn't attached to the MooseMesh yet, so have to tell it not to remove
          // remote elements independently
          mesh.allow_remote_element_removal(false);
      }
    }
  }
}

backup() [1/2]

std::vector< std::filesystem::path > MooseApp::backup

(

const std::filesystem::path &

folder_base

)

Backs up the application to the folder folder_base.

Returns

The files that are written in the backup

Definition at line 1215 of file MooseApp.C.

Referenced by Checkpoint::output().

{
  TIME_SECTION("backup", 2, "Backing Up Application to File");

  preBackup();

  RestartableDataWriter writer(*this, _restartable_data);
  return writer.write(folder_base);
}

backup() [2/2]

std::unique_ptr< Backup > MooseApp::backup

(

)

Backs up the application memory in a Backup.

Returns

The backup

Definition at line 1226 of file MooseApp.C.

Referenced by finalizeRestore(), and restore().

{
  TIME_SECTION("backup", 2, "Backing Up Application");

  RestartableDataWriter writer(*this, _restartable_data);

  preBackup();

  auto backup = std::make_unique<Backup>();
  writer.write(*backup->header, *backup->data);

  return backup;
}

builder()

Moose::Builder& MooseApp::builder ( )

inline

Returns a writable reference to the builder.

Definition at line 204 of file MooseApp.h.

Referenced by MeshOnlyAction::act(), SetupMeshAction::act(), and MultiApp::createLocalApp().

{ return _builder; }

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

checkInput()

bool MooseApp::checkInput ( ) const

inline

Returns whether the Application is running in check input mode.

Definition at line 905 of file MooseApp.h.

{ return _check_input; }

checkMetaDataIntegrity()

void MooseApp::checkMetaDataIntegrity

(

)

const

Function to check the integrity of the restartable meta data structure.

Definition at line 2750 of file MooseApp.C.

Referenced by SetupRecoverFileBaseAction::act().

{
  for (auto map_iter = _restartable_meta_data.begin(); map_iter != _restartable_meta_data.end();
       ++map_iter)
  {
    const RestartableDataMapName & name = map_iter->first;
    const RestartableDataMap & meta_data = map_iter->second.first;

    std::vector<std::string> not_declared;

    for (const auto & data : meta_data)
      if (!data.declared())
        not_declared.push_back(data.name());

    if (!not_declared.empty())
    {
      std::ostringstream oss;
      std::copy(
          not_declared.begin(), not_declared.end(), infix_ostream_iterator<std::string>(oss, ", "));

      mooseError("The following '",
                 name,
                 "' meta-data properties were retrieved but never declared: ",
                 oss.str());
    }
  }
}

checkpointSuffix()

const std::string & MooseApp::checkpointSuffix ( )

static

The file suffix for the checkpoint mesh.

Definition at line 2397 of file MooseApp.C.

Referenced by SetupRecoverFileBaseAction::act(), MooseMesh::init(), and Checkpoint::output().

{
  static const std::string suffix = "-mesh.cpr";
  return suffix;
}

commandLine()

std::shared_ptr<CommandLine> MooseApp::commandLine ( ) const

inline

Get the command line.

Returns

The reference to the command line object Setup options based on InputParameters.

Definition at line 413 of file MooseApp.h.

Referenced by FEProblemBase::addMultiApp(), Moose::Builder::build(), MultiApp::createApp(), MultiApp::createLocalApp(), Moose::Builder::errorCheck(), Moose::Builder::hitCLIFilter(), MooseServer::parseDocumentForDiagnostics(), and ExodusFormatter::printInputFile().

{ return _command_line; }

constructingMeshGenerators()

bool MooseApp::constructingMeshGenerators ( ) const

virtual

Whether this app is constructing mesh generators.

This is virtual to allow MooseUnitApp to override it so that we can construct MeshGenerators in unit tests

Definition at line 2849 of file MooseApp.C.

Referenced by MeshGenerator::addChildMeshGenerator(), MeshGeneratorSystem::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addParentMeshGenerator(), MeshGenerator::checkGetMesh(), MeshGeneratorSystem::createMeshGenerator(), MeshGeneratorSystem::createMeshGeneratorOrder(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), and MeshGeneratorSystem::getMeshGeneratorOutput().

{
  return _action_warehouse.getCurrentTaskName() == "create_added_mesh_generators" ||
         _mesh_generator_system.appendingMeshGenerators();
}

copyInputs()

bool MooseApp::copyInputs ( ) const

private

Handles the copy_inputs input parameter logic: Checks to see whether the passed argument is valid (a readable installed directory) and recursively copies those files into a read/writable location for the user.

Returns

a Boolean value used to indicate whether the application should exit early

Definition at line 1591 of file MooseApp.C.

Referenced by run().

{
  if (isParamValid("copy_inputs"))
  {
    // Get command line argument following --copy-inputs on command line
    auto dir_to_copy = getParam<std::string>("copy_inputs");

    if (dir_to_copy.empty())
      mooseError("Error retrieving directory to copy");
    if (dir_to_copy.back() != '/')
      dir_to_copy += '/';

    // This binary name is the actual binary. That is, if we called a symlink it'll
    // be the name of what the symlink points to
    auto binname = appBinaryName();
    if (binname == "")
      mooseError("could not locate installed tests to run (unresolved binary/app name)");

    auto src_dir = MooseUtils::installedInputsDir(binname,
                                                  dir_to_copy,
                                                  "Rerun binary with " +
                                                      _pars.getCommandLineSyntax("show_inputs")[0] +
                                                      " to get a list of installable directories.");

    // Use the command line here because if we have a symlink to another binary,
    // we want to dump into a directory that is named after the symlink not the true binary
    auto dst_dir = _command_line->getExecutableNameBase() + "/" + dir_to_copy;
    auto cmdname = _command_line->getExecutableName();
    if (cmdname.find_first_of("/") != std::string::npos)
      cmdname = cmdname.substr(cmdname.find_first_of("/") + 1, std::string::npos);

    if (MooseUtils::pathExists(dst_dir))
      mooseError(
          "The directory \"./",
          dst_dir,
          "\" already exists.\nTo update/recopy the contents of this directory, rename (\"mv ",
          dst_dir,
          " new_dir_name\") or remove (\"rm -r ",
          dst_dir,
          "\") the existing directory.\nThen re-run \"",
          cmdname,
          " --copy-inputs ",
          dir_to_copy,
          "\".");

    std::string cmd = "mkdir -p " + dst_dir + "; rsync -av " + src_dir + " " + dst_dir;

    TIME_SECTION("copy_inputs", 2, "Copying Inputs");

    // Only perform the copy on the root processor
    int return_value = 0;
    if (processor_id() == 0)
      return_value = system(cmd.c_str());
    _communicator.broadcast(return_value);

    if (WIFEXITED(return_value) && WEXITSTATUS(return_value) != 0)
      mooseError("Failed to copy the requested directory.");
    Moose::out << "Directory successfully copied into ./" << dst_dir << '\n';
    return true;
  }
  return false;
}

createExecutors()

void MooseApp::createExecutors

(

)

After adding all of the Executor Params - this function will actually cause all of them to be built.

Definition at line 1412 of file MooseApp.C.

Referenced by AddExecutorAction::act().

{
  // Do we have any?
  if (_executor_params.empty())
    return;

  // Holds the names of Executors that may be the root executor
  std::list<std::string> possibly_root;

  // What is already built
  std::map<std::string, bool> already_built;

  // The Executors that are currently candidates for being roots
  std::list<std::string> possible_roots;

  // The current line of dependencies - used for finding cycles
  std::list<std::string> current_branch;

  // Build the NullExecutor
  {
    auto params = _factory.getValidParams("NullExecutor");
    _null_executor = _factory.create<NullExecutor>("NullExecutor", "_null_executor", params);
  }

  for (const auto & params_entry : _executor_params)
  {
    const auto & name = params_entry.first;

    // Did we already make this one?
    if (_executors.find(name) != _executors.end())
      continue;

    possible_roots.emplace_back(name);

    recursivelyCreateExecutors(name, possible_roots, current_branch);
  }

  // If there is more than one possible root - error
  if (possible_roots.size() > 1)
  {
    auto root_string_it = possible_roots.begin();

    std::stringstream roots_string;

    roots_string << *root_string_it++;

    for (; root_string_it != possible_roots.end(); ++root_string_it)
      roots_string << ", " << *root_string_it;

    mooseError("Multiple Executor roots found: ", roots_string.str());
  }

  // Set the root executor
  _executor = _executors[possible_roots.front()];
}

createMinimalApp()

void MooseApp::createMinimalApp ( )

private

Method for creating the minimum required actions for an application (no input file)

Mimics the following input file:

[Mesh] type = GeneratedMesh dim = 1 nx = 1 []

[Executioner] type = Transient num_steps = 1 dt = 1 []

[Problem] solve = false []

[Outputs] console = false []

Definition at line 2249 of file MooseApp.C.

Referenced by setupOptions().

{
  TIME_SECTION("createMinimalApp", 3, "Creating Minimal App");

  // SetupMeshAction
  {
    // Build the Action parameters
    InputParameters action_params = _action_factory.getValidParams("SetupMeshAction");
    action_params.set<std::string>("type") = "GeneratedMesh";

    // Create The Action
    std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
        _action_factory.create("SetupMeshAction", "Mesh", action_params));

    // Set the object parameters
    InputParameters & params = action->getObjectParams();
    params.set<MooseEnum>("dim") = "1";
    params.set<unsigned int>("nx") = 1;

    // Add Action to the warehouse
    _action_warehouse.addActionBlock(action);
  }

  // Executioner
  {
    // Build the Action parameters
    InputParameters action_params = _action_factory.getValidParams("CreateExecutionerAction");
    action_params.set<std::string>("type") = "Transient";

    // Create the action
    std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
        _action_factory.create("CreateExecutionerAction", "Executioner", action_params));

    // Set the object parameters
    InputParameters & params = action->getObjectParams();
    params.set<unsigned int>("num_steps") = 1;
    params.set<Real>("dt") = 1;

    // Add Action to the warehouse
    _action_warehouse.addActionBlock(action);
  }

  // Problem
  {
    // Build the Action parameters
    InputParameters action_params = _action_factory.getValidParams("CreateProblemDefaultAction");
    action_params.set<bool>("_solve") = false;

    // Create the action
    std::shared_ptr<Action> action = std::static_pointer_cast<Action>(
        _action_factory.create("CreateProblemDefaultAction", "Problem", action_params));

    // Add Action to the warehouse
    _action_warehouse.addActionBlock(action);
  }

  // Outputs
  {
    // Build the Action parameters
    InputParameters action_params = _action_factory.getValidParams("CommonOutputAction");
    action_params.set<bool>("console") = false;

    // Create action
    std::shared_ptr<Action> action =
        _action_factory.create("CommonOutputAction", "Outputs", action_params);

    // Add Action to the warehouse
    _action_warehouse.addActionBlock(action);
  }

  _action_warehouse.build();
}

createRecoverablePerfGraph()

PerfGraph & MooseApp::createRecoverablePerfGraph ( )

private

Creates a recoverable PerfGraph.

This is a separate method so that it can be used in the constructor (multiple calls are required to declare it).

Definition at line 2818 of file MooseApp.C.

{
  registerRestartableNameWithFilter("perf_graph", Moose::RESTARTABLE_FILTER::RECOVERABLE);

  auto perf_graph =
      std::make_unique<RestartableData<PerfGraph>>("perf_graph",
                                                   this,
                                                   type() + " (" + name() + ')',
                                                   *this,
                                                   getParam<bool>("perf_graph_live_all"),
                                                   !getParam<bool>("disable_perf_graph_live"));

  return dynamic_cast<RestartableData<PerfGraph> &>(
             registerRestartableData(std::move(perf_graph), 0, false))
      .set();
}

createRecoverableSolutionInvalidity()

SolutionInvalidity & MooseApp::createRecoverableSolutionInvalidity ( )

private

Creates a recoverable SolutionInvalidity.

This is a separate method so that it can be used in the constructor (multiple calls are required to declare it).

Definition at line 2836 of file MooseApp.C.

{
  registerRestartableNameWithFilter("solution_invalidity", Moose::RESTARTABLE_FILTER::RECOVERABLE);

  auto solution_invalidity =
      std::make_unique<RestartableData<SolutionInvalidity>>("solution_invalidity", nullptr, *this);

  return dynamic_cast<RestartableData<SolutionInvalidity> &>(
             registerRestartableData(std::move(solution_invalidity), 0, false))
      .set();
}

createRMFromTemplateAndInit()

RelationshipManager & MooseApp::createRMFromTemplateAndInit ( const RelationshipManager &  template_rm, MooseMesh &  moose_mesh, MeshBase &  mesh, const DofMap *  dof_map = nullptr  )

private

Take an input relationship manager, clone it, and then initialize it with provided mesh and optional dof_map.

Parameters

template_rm	The relationship manager template from which we will clone
moose_mesh	The moose mesh to use for initialization
mesh	The mesh to use for initialization
dof_map	An optional parameter that, if provided, will be used to help init the cloned relationship manager

Returns

a reference to the cloned and initialized relationship manager

Definition at line 2493 of file MooseApp.C.

Referenced by attachRelationshipManagers().

{
  auto & mesh_to_clone = _template_to_clones[&template_rm];
  auto it = mesh_to_clone.find(&mesh);
  if (it != mesh_to_clone.end())
  {
    // We've already created a clone for this mesh
    auto & clone_rm = *it->second;
    if (!clone_rm.dofMap() && dof_map)
      // We didn't have a DofMap before, but now we do, so we should re-init
      clone_rm.init(moose_mesh, mesh, dof_map);
    else if (clone_rm.dofMap() && dof_map && (clone_rm.dofMap() != dof_map))
      mooseError("Attempting to create and initialize an existing clone with a different DofMap. "
                 "This should not happen.");

    return clone_rm;
  }

  // It's possible that this method is going to get called for multiple different MeshBase
  // objects. If that happens, then we *cannot* risk having a MeshBase object with a ghosting
  // functor that is init'd with another MeshBase object. So the safe thing to do is to make a
  // different RM for every MeshBase object that gets called here. Then the
  // RelationshipManagers stored here in MooseApp are serving as a template only
  auto pr = mesh_to_clone.emplace(
      std::make_pair(&const_cast<const MeshBase &>(mesh),
                     dynamic_pointer_cast<RelationshipManager>(template_rm.clone())));
  mooseAssert(pr.second, "An insertion should have happened");
  auto & clone_rm = *pr.first->second;
  clone_rm.init(moose_mesh, mesh, dof_map);
  return clone_rm;
}

defaultAutomaticScaling()

bool MooseApp::defaultAutomaticScaling ( ) const

inline

Whether to enable automatic scaling by default.

Definition at line 998 of file MooseApp.h.

{ return _automatic_automatic_scaling; }

disableCheckUnusedFlag()

void MooseApp::disableCheckUnusedFlag

(

)

Removes warnings and error checks for unrecognized variables in the input file.

Definition at line 1321 of file MooseApp.C.

{
  _enable_unused_check = OFF;
}

dynamicAllRegistration()

void MooseApp::dynamicAllRegistration	(	const std::string &	app_name,
		Factory *	factory,
		ActionFactory *	action_factory,
		Syntax *	syntax,
		std::string	library_path,
		const std::string &	library_name
	)

Thes methods are called to register applications or objects on demand.

This method attempts to load a dynamic library and register it when it is needed. Throws an error if no suitable library is found that contains the app_name in question.

Definition at line 1996 of file MooseApp.C.

Referenced by DynamicObjectRegistrationAction::DynamicObjectRegistrationAction().

{
#ifdef LIBMESH_HAVE_DLOPEN
  Parameters params;
  params.set<std::string>("app_name") = app_name;
  params.set<RegistrationType>("reg_type") = REGALL;
  params.set<std::string>("registration_method") = app_name + "__registerAll";
  params.set<std::string>("library_path") = library_path;
  params.set<std::string>("library_name") =
      library_name.empty() ? appNameToLibName(app_name) : library_name;

  params.set<Factory *>("factory") = factory;
  params.set<Syntax *>("syntax") = syntax;
  params.set<ActionFactory *>("action_factory") = action_factory;
  params.set<bool>("library_load_dependencies") = false;

  dynamicRegistration(params);
#else
  libmesh_ignore(app_name, factory, action_factory, syntax, library_path, library_name);
  mooseError("Dynamic Loading is either not supported or was not detected by libMesh configure.");
#endif
}

dynamicAppRegistration()

void MooseApp::dynamicAppRegistration	(	const std::string &	app_name,
		std::string	library_path,
		const std::string &	library_name,
		bool	lib_load_deps
	)

Definition at line 1939 of file MooseApp.C.

Referenced by MultiApp::createApps().

{
#ifdef LIBMESH_HAVE_DLOPEN
  Parameters params;
  params.set<std::string>("app_name") = app_name;
  params.set<RegistrationType>("reg_type") = APPLICATION;
  params.set<std::string>("registration_method") = app_name + "__registerApps";
  params.set<std::string>("library_path") = library_path;

  const auto effective_library_name =
      library_name.empty() ? appNameToLibName(app_name) : library_name;
  params.set<std::string>("library_name") = effective_library_name;
  params.set<bool>("library_load_dependencies") = lib_load_deps;

  const auto paths = getLibrarySearchPaths(library_path);
  std::ostringstream oss;

  auto successfully_loaded = false;
  if (paths.empty())
    oss << '"' << app_name << "\" is not a registered application name.\n"
        << "No search paths were set. We made no attempts to locate the corresponding library "
           "file.\n";
  else
  {
    dynamicRegistration(params);

    // At this point the application should be registered so check it
    if (!AppFactory::instance().isRegistered(app_name))
    {
      oss << '"' << app_name << "\" is not a registered application name.\n"
          << "Unable to locate library archive for \"" << app_name
          << "\".\nWe attempted to locate the library archive \"" << effective_library_name
          << "\" in the following paths:\n\t";
      std::copy(paths.begin(), paths.end(), infix_ostream_iterator<std::string>(oss, "\n\t"));
    }
    else
      successfully_loaded = true;
  }

  if (!successfully_loaded)
  {
    oss << "\nMake sure you have compiled the library and either set the \"library_path\" "
           "variable in your input file or exported \"MOOSE_LIBRARY_PATH\".\n";

    mooseError(oss.str());
  }

#else
  libmesh_ignore(app_name, library_path, library_name, lib_load_deps);
  mooseError("Dynamic Loading is either not supported or was not detected by libMesh configure.");
#endif
}

dynamicRegistration()

void MooseApp::dynamicRegistration ( const Parameters &  params )

protected

Helper method for dynamic loading of objects.

Definition at line 2025 of file MooseApp.C.

Referenced by dynamicAllRegistration(), and dynamicAppRegistration().

{
  const auto paths = getLibrarySearchPaths(params.get<std::string>("library_path"));
  const auto library_name = params.get<std::string>("library_name");

  // Attempt to dynamically load the library
  for (const auto & path : paths)
    if (MooseUtils::checkFileReadable(path + '/' + library_name, false, false))
      loadLibraryAndDependencies(
          path + '/' + library_name, params, params.get<bool>("library_load_dependencies"));
}

errorCheck()

void MooseApp::errorCheck ( )

protected

Runs post-initialization error checking that cannot be run correctly unless the simulation has been fully set up and initialized.

Definition at line 1123 of file MooseApp.C.

Referenced by executeExecutioner(), and run().

{
  bool warn = _enable_unused_check == WARN_UNUSED;
  bool err = _enable_unused_check == ERROR_UNUSED;

  _builder.errorCheck(*_comm, warn, err);

  auto apps = feProblem().getMultiAppWarehouse().getObjects();
  for (auto app : apps)
    for (unsigned int i = 0; i < app->numLocalApps(); i++)
      app->localApp(i)->errorCheck();
}

errorOnJacobianNonzeroReallocation()

virtual bool MooseApp::errorOnJacobianNonzeroReallocation ( ) const

inlinevirtual

Whether this application should by default error on Jacobian nonzero reallocations.

The application level setting can always be overridden by setting the error_on_jacobian_nonzero_reallocation parameter in the Problem block of the input file

Definition at line 1032 of file MooseApp.h.

{ return false; }

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

executeExecutioner()

void MooseApp::executeExecutioner ( )

virtual

Execute the Executioner that was built.

Definition at line 1137 of file MooseApp.C.

Referenced by run().

{
  TIME_SECTION("executeExecutioner", 3);

  // If ready to exit has been set, then just return
  if (_ready_to_exit)
    return;

  // run the simulation
  if (_use_executor && _executor)
  {
    Moose::PetscSupport::petscSetupOutput(_command_line.get());

    _executor->init();
    errorCheck();
    auto result = _executor->exec();
    if (!result.convergedAll())
      mooseError(result.str());
  }
  else if (_executioner)
  {
    Moose::PetscSupport::petscSetupOutput(_command_line.get());
    _executioner->init();
    errorCheck();
    _executioner->execute();
  }
  else
    mooseError("No executioner was specified (go fix your input file)");
}

feProblem()

FEProblemBase & MooseApp::feProblem

(

)

const

Definition at line 1327 of file MooseApp.C.

Referenced by attachRelationshipManagers(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), errorCheck(), AutomaticMortarGeneration::initOutput(), removeRelationshipManager(), and setOutputFileBase().

{
  return _executor.get() ? _executor->feProblem() : _executioner->feProblem();
}

finalizeRestore()

std::unique_ptr< Backup > MooseApp::finalizeRestore

(

)

Finalizes (closes) the restoration process done in restore().

Returns

The underlying Backup that was used to do the restoration (if any, will be null when backed up from file); can be ignored to destruct it

This releases access to the stream in which the restore was loaded from and makes it no longer possible to restore additional data.

Definition at line 1283 of file MooseApp.C.

Referenced by FEProblemBase::initialSetup().

{
  if (!_rd_reader.isRestoring())
    mooseError("MooseApp::finalizeRestore(): Not currently restoring");

  // This gives us access to the underlying streams so that we can return it if needed
  auto input_streams = _rd_reader.clear();

  std::unique_ptr<Backup> backup;

  // Give them back a backup if this restore started from a Backup, in which case
  // the two streams in the Backup are formed into StringInputStreams
  if (auto header_string_input = dynamic_cast<StringInputStream *>(input_streams.header.get()))
  {
    auto data_string_input = dynamic_cast<StringInputStream *>(input_streams.data.get());
    mooseAssert(data_string_input, "Should also be a string input");

    auto header_sstream = header_string_input->release();
    mooseAssert(header_sstream, "Header not available");

    auto data_sstream = data_string_input->release();
    mooseAssert(data_sstream, "Data not available");

    backup = std::make_unique<Backup>();
    backup->header = std::move(header_sstream);
    backup->data = std::move(data_sstream);
  }

  return backup;
}

fixedPointConfig()

FixedPointConfig& MooseApp::fixedPointConfig ( )

inline

This info is stored here because we need a "globalish" place to put it in order to allow communication between a multiapp and solver-specific internals (i.e.

relating to fixed-point inner loops like picard, etc.) for handling subapp-specific modifications necessary for those solve processes.

Definition at line 381 of file MooseApp.h.

Referenced by FixedPointSolve::FixedPointSolve().

{ return _fixed_point_config; }

getActionFactory()

ActionFactory& MooseApp::getActionFactory ( )

inline

Retrieve a writable reference to the ActionFactory associated with this App.

Definition at line 401 of file MooseApp.h.

Referenced by Action::Action().

{ return _action_factory; }

getCheckpointDirectories()

std::list< std::string > MooseApp::getCheckpointDirectories

(

)

const

Get all checkpoint directories.

Returns

A Set of checkpoint directories

Definition at line 1721 of file MooseApp.C.

Referenced by getCheckpointFiles().

{
  // Storage for the directory names
  std::list<std::string> checkpoint_dirs;

  // Add the directories added with Outputs/checkpoint=true input syntax
  checkpoint_dirs.push_back(getOutputFileBase() + "_cp");

  // Add the directories from any existing checkpoint output objects
  const auto & actions = _action_warehouse.getActionListByName("add_output");
  for (const auto & action : actions)
  {
    // Get the parameters from the MooseObjectAction
    MooseObjectAction * moose_object_action = dynamic_cast<MooseObjectAction *>(action);
    if (!moose_object_action)
      continue;

    const InputParameters & params = moose_object_action->getObjectParams();
    if (moose_object_action->getParam<std::string>("type") == "Checkpoint")
    {
      // Unless file_base was explicitly set by user, we cannot rely on it, as it will be changed
      // later
      const std::string cp_dir =
          _file_base_set_by_user ? params.get<std::string>("file_base")
                                 : (getOutputFileBase(true) + "_" + moose_object_action->name());
      checkpoint_dirs.push_back(cp_dir + "_cp");
    }
  }
  return checkpoint_dirs;
}

getCheckpointFiles()

std::list< std::string > MooseApp::getCheckpointFiles

(

)

const

Extract all possible checkpoint file names.

Returns

A Set of checkpoint filenames

Definition at line 1753 of file MooseApp.C.

Referenced by setRestartRecoverFileBase().

{
  auto checkpoint_dirs = getCheckpointDirectories();
  return MooseUtils::getFilesInDirs(checkpoint_dirs, false);
}

getCommunicator()

const std::shared_ptr<Parallel::Communicator> MooseApp::getCommunicator ( ) const

inline

Definition at line 1001 of file MooseApp.h.

Referenced by MooseServer::parseDocumentForDiagnostics().

{ return _comm; }

getCurrentActionHitNode()

const hit::Node * MooseApp::getCurrentActionHitNode

(

)

const

Returns

The hit node that is responsible for creating the current action that is running, if any

Can be used to link objects that are created by an action to the action that created them in input

Definition at line 2420 of file MooseApp.C.

Referenced by ActionFactory::create(), and Factory::initialize().

{
  if (const auto action = _action_warehouse.getCurrentAction())
    return action->parameters().getHitNode();
  return nullptr;
}

getDistributedMeshOnCommandLine()

bool MooseApp::getDistributedMeshOnCommandLine ( ) const

inline

Returns true if the user specified –distributed-mesh (or –parallel-mesh, for backwards compatibility) on the command line and false otherwise.

Definition at line 452 of file MooseApp.h.

Referenced by MooseMesh::determineUseDistributedMesh().

{ return _distributed_mesh_on_command_line; }

getExecuteOnEnum()

const ExecFlagEnum& MooseApp::getExecuteOnEnum ( ) const

inline

Return the app level ExecFlagEnum, this contains all the available flags for the app.

Definition at line 983 of file MooseApp.h.

Referenced by FEProblemBase::initialSetup(), and EigenExecutionerBase::normalizeSolution().

{ return _execute_flags; }

getExecutioner()

Executioner * MooseApp::getExecutioner

(

)

const

Retrieve the Executioner for this App.

Definition at line 1483 of file MooseApp.C.

Referenced by CheckIntegrityAction::act(), AddTimeStepperAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), ComposeTimeStepperAction::act(), LazyCoupleable::coupled(), EigenProblem::doFreeNonlinearPowerIterations(), EigenKernel::EigenKernel(), PseudoTimestep::execute(), IterationInfo::execute(), PIDTransientControl::execute(), Terminator::execute(), ChangeOverFixedPointPostprocessor::finalize(), NumFixedPointIterations::getValue(), FEProblemBase::init(), Console::initialSetup(), NumFailedTimeSteps::NumFailedTimeSteps(), ConsoleUtils::outputExecutionInformation(), MultiApp::preTransfer(), setOutputFileBase(), TimeIntervalTimes::TimeIntervalTimes(), and TimePeriod::TimePeriod().

{
  return _executioner.get() ? _executioner.get() : _executor.get();
}

getExecutor() [1/2]

Executor* MooseApp::getExecutor ( ) const

inline

Definition at line 319 of file MooseApp.h.

Referenced by CheckIntegrityAction::act(), ExecutorInterface::getExecutor(), FEProblemBase::getExecutor(), and ExecutorInterface::getExecutorByName().

{ return _executor.get(); }

getExecutor() [2/2]

Executor & MooseApp::getExecutor	(	const std::string &	name,
		bool	fail_if_not_found = true
	)

Get an Executor.

Parameters

name	The name of the Executor
fail_if_not_found	Whether or not to fail if the executor doesn't exist. If this is false then this function will return a NullExecutor

Definition at line 1469 of file MooseApp.C.

{
  auto it = _executors.find(name);

  if (it != _executors.end())
    return *it->second;

  if (fail_if_not_found)
    mooseError("Executor not found: ", name);

  return *_null_executor;
}

getExodusFileRestart()

bool MooseApp::getExodusFileRestart ( ) const

inline

Whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh.

Definition at line 425 of file MooseApp.h.

Referenced by SetupMeshCompleteAction::act(), FileMesh::buildMesh(), FileMeshGenerator::generate(), and FEProblemBase::initialSetup().

{ return _initial_from_file; }

getExReaderForRestart()

ExodusII_IO* MooseApp::getExReaderForRestart ( ) const

inline

Get the Exodus reader to restart variables from an Exodus mesh file.

Definition at line 435 of file MooseApp.h.

Referenced by FEProblemBase::checkICRestartError(), and FEProblemBase::initialSetup().

{ return _ex_reader.get(); }

getFactory()

Factory& MooseApp::getFactory ( )

inline

Retrieve a writable reference to the Factory associated with this App.

Definition at line 396 of file MooseApp.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), MeshGenerator::addMeshSubgenerator(), FVFluxKernel::adjustRMGhostLayers(), AStableDirk4::AStableDirk4(), SingleRankPartitioner::clone(), RandomPartitioner::clone(), BlockWeightedPartitioner::clone(), GhostLowerDElems::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), PetscExternalPartitioner::clone(), LibmeshPartitioner::clone(), HierarchicalGridPartitioner::clone(), GridPartitioner::clone(), ElementSideNeighborLayers::clone(), ElementPointNeighborLayers::clone(), RedistributeProperties::clone(), ProxyRelationshipManager::clone(), OversampleOutput::cloneMesh(), MeshGeneratorSystem::createMeshGenerator(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), MooseObject::MooseObject(), OverlayMeshGenerator::OverlayMeshGenerator(), TiledMesh::safeClone(), FileMesh::safeClone(), ImageMesh::safeClone(), SpiralAnnularMesh::safeClone(), GeneratedMesh::safeClone(), RinglebMesh::safeClone(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), MeshGeneratorMesh::safeClone(), StitchedMesh::safeClone(), PatternedMesh::safeClone(), Transient::setupTimeIntegrator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

{ return _factory; }

getFileName()

std::string MooseApp::getFileName

(

bool

stripLeadingPath = true

)

const

Return the primary (first) filename that was parsed Note: When stripLeadingPath is false, this function returns the same name as getInputFileName() method when the input file is not a link.

Definition at line 1767 of file MooseApp.C.

Referenced by ProgressOutput::output().

{
  return _builder.getPrimaryFileName(stripLeadingPath);
}

getFPTrapFlag()

bool MooseApp::getFPTrapFlag ( ) const

inline

Returns whether FPE trapping is turned on (either because of debug or user requested)

Definition at line 908 of file MooseApp.h.

{ return _trap_fpe; }

getFrameworkVersion()

std::string MooseApp::getFrameworkVersion

(

)

const

Returns the framework version.

Definition at line 670 of file MooseApp.C.

{
  return MOOSE_VERSION;
}

getGlobalTimeOffset()

Real MooseApp::getGlobalTimeOffset ( ) const

inline

Each App has it's own local time.

The "global" time of the whole problem might be different. This offset is how far off the local App time is from the global time.

Definition at line 296 of file MooseApp.h.

Referenced by Tecplot::output(), Nemesis::output(), Exodus::outputEmptyTimestep(), Exodus::outputNodalVariables(), and TransientMultiApp::solveStep().

{ return _global_time_offset; }

getInputFileNames()

const std::vector< std::string > & MooseApp::getInputFileNames

(

)

const

Returns

the input file names set in the Parser

Definition at line 1059 of file MooseApp.C.

Referenced by Console::outputInput(), and setupOptions().

{
  mooseAssert(_parser, "Parser is not set");
  return _parser->getInputFileNames();
}

getInputParameterWarehouse()

InputParameterWarehouse & MooseApp::getInputParameterWarehouse

(

)

Get the InputParameterWarehouse for MooseObjects.

Definition at line 2225 of file MooseApp.C.

Referenced by FEProblemBase::addMaterialHelper(), MooseBaseParameterInterface::connectControllableParams(), ActionFactory::create(), Factory::initialize(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), ActionWarehouse::printInputFile(), and Factory::releaseSharedObjects().

{
  return *_input_parameter_warehouse;
}

getInstallableInputs()

std::string MooseApp::getInstallableInputs ( ) const

privatevirtual

Method to retrieve the installable inputs from a given applications <app>Revision.h file.

Definition at line 1585 of file MooseApp.C.

Referenced by showInputs().

{
  return "tests";
}

getInterfaceObjects()

template<class T >

const std::vector< T * > & MooseApp::getInterfaceObjects

(

)

const

Gets the registered interface objects for a given interface.

For this to work, the interface must register itself using registerInterfaceObject.

Definition at line 1526 of file MooseApp.h.

Referenced by DeclareLateReportersAction::act(), ResolveOptionalMaterialPropertiesAction::act(), Coupleable::checkWritableVar(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), and PetscOutput::solveSetup().

{
  static_assert(!std::is_base_of<MooseObject, T>::value, "T is not an interface");

  const auto it = _interface_registry.find(typeid(T));
  if (it != _interface_registry.end())
    return static_cast<InterfaceRegistryObjects<T> *>(it->second.get())->_objects;
  const static std::vector<T *> empty;
  return empty;
}

getLastInputFileName()

const std::string & MooseApp::getLastInputFileName

(

)

const

Returns

The last input filename set (if any)

Definition at line 1066 of file MooseApp.C.

Referenced by setupOptions().

{
  mooseAssert(_parser, "Parser is not set");
  return _parser->getLastInputFileName();
}

getLibrarySearchPaths()

std::set< std::string > MooseApp::getLibrarySearchPaths

(

const std::string &

library_path_from_param

)

const

Return the paths searched by MOOSE when loading libraries.

Definition at line 2199 of file MooseApp.C.

Referenced by dynamicAppRegistration(), and dynamicRegistration().

{
  std::set<std::string> paths;

  if (!library_path.empty())
  {
    std::vector<std::string> tmp_paths;
    MooseUtils::tokenize(library_path, tmp_paths, 1, ":");

    paths.insert(tmp_paths.begin(), tmp_paths.end());
  }

  char * moose_lib_path_env = std::getenv("MOOSE_LIBRARY_PATH");
  if (moose_lib_path_env)
  {
    std::string moose_lib_path(moose_lib_path_env);
    std::vector<std::string> tmp_paths;
    MooseUtils::tokenize(moose_lib_path, tmp_paths, 1, ":");

    paths.insert(tmp_paths.begin(), tmp_paths.end());
  }

  return paths;
}

getLoadedLibraryPaths()

std::set< std::string > MooseApp::getLoadedLibraryPaths

(

)

const

Return the paths of loaded libraries.

Definition at line 2188 of file MooseApp.C.

Referenced by Factory::reportUnregisteredError().

{
  // Return the paths but not the open file handles
  std::set<std::string> paths;
  for (const auto & it : _lib_handles)
    paths.insert(it.first);

  return paths;
}

getMeshGenerator()

const MeshGenerator& MooseApp::getMeshGenerator ( const std::string &  name ) const

inline

Returns

The MeshGenerator with the name name.

Definition at line 849 of file MooseApp.h.

Referenced by MeshGenerator::generateInternal().

  {
    return _mesh_generator_system.getMeshGenerator(name);
  }

getMeshGeneratorMesh()

std::unique_ptr<MeshBase> MooseApp::getMeshGeneratorMesh ( )

inline

Returns

The final mesh generated by the mesh generator system

Definition at line 857 of file MooseApp.h.

  {
    return _mesh_generator_system.getSavedMesh(_mesh_generator_system.mainMeshGeneratorName());
  }

getMeshGeneratorNames()

std::vector<std::string> MooseApp::getMeshGeneratorNames ( ) const

inline

Returns

The names of all mesh generators

See MeshGeneratorSystem::getMeshGeneratorNames()

Definition at line 867 of file MooseApp.h.

Referenced by SetupMeshAction::act().

  {
    return _mesh_generator_system.getMeshGeneratorNames();
  }

getMeshGeneratorSystem()

MeshGeneratorSystem& MooseApp::getMeshGeneratorSystem ( )

inline

Gets the system that manages the MeshGenerators.

Definition at line 820 of file MooseApp.h.

Referenced by ExecuteMeshGenerators::act(), SetupMeshAction::act(), CreateAddedMeshGenerators::act(), MeshGenerator::checkGetMesh(), ExtraNodesetGenerator::generate(), SideSetsFromNormalsGenerator::generate(), MeshGenerator::getMeshByName(), and MeshGenerator::MeshGenerator().

{ return _mesh_generator_system; }

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

Referenced by ReporterTransferInterface::checkHasReporterValue(), Coupleable::checkWritableVar(), MooseBaseParameterInterface::connectControllableParams(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

{ return _app; }

getNullExecutor()

NullExecutor* MooseApp::getNullExecutor ( ) const

inline

Definition at line 320 of file MooseApp.h.

Referenced by ExecutorInterface::getExecutor().

{ return _null_executor.get(); }

getOutputFileBase()

std::string MooseApp::getOutputFileBase

(

bool

for_non_moose_build_output = false

)

const

Get the output file base name.

Parameters

for_non_moose_build_output

True for getting the file base for outputs generated with Outputs/[outputname] input syntax.

Returns

The file base name used by output objects Note: for_non_moose_build_output does not affect the returned value when this is a subapp. for_non_moose_build_output also does not affect the returned value when Outputs/file_base parameter is available. When for_non_moose_build_output does affect the returned value, i.e. master without Outputs/file_base, the suffix _out is removed.

Definition at line 1073 of file MooseApp.C.

Referenced by getCheckpointDirectories(), OutputWarehouse::resetFileBase(), and MultiApp::setAppOutputFileBase().

{
  if (_file_base_set_by_user || for_non_moose_build_output || _multiapp_level)
    return _output_file_base;
  else
    return _output_file_base + "_out";
}

getOutputFileNumbers()

const std::map<std::string, unsigned int>& MooseApp::getOutputFileNumbers ( ) const

inline

Store a map of outputter names and file numbers The MultiApp system requires this to get the file numbering to propogate down through the multiapps.

See also

MultiApp TransientMultiApp

Definition at line 532 of file MooseApp.h.

Referenced by TransientMultiApp::setupApp().

  {
    return _output_file_numbers;
  }

getOutputPosition()

Point MooseApp::getOutputPosition ( ) const

inline

Get the output position.

Returns

The position offset for the output.

Definition at line 266 of file MooseApp.h.

Referenced by MultiApp::createApp(), Exodus::output(), and MultiApp::parentOutputPositionChanged().

{ return _output_position; }

getOutputWarehouse()

OutputWarehouse & MooseApp::getOutputWarehouse

(

)

Get the OutputWarehouse objects.

Definition at line 1773 of file MooseApp.C.

Referenced by AutoCheckpointAction::act(), CommonOutputAction::act(), FEProblemBase::addOutput(), FEProblemBase::allowOutput(), MooseBase::callMooseError(), CheckOutputAction::checkConsoleOutput(), CheckOutputAction::checkMaterialOutput(), CheckOutputAction::checkPerfLogOutput(), CheckOutputAction::checkVariableOutput(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), MultiApp::createApp(), FEProblemBase::customSetup(), FEProblemBase::forceOutput(), TimePeriod::initialSetup(), FEProblemBase::initialSetup(), AutomaticMortarGeneration::initOutput(), AdvancedOutput::initOutputList(), EigenProblem::initPetscOutputAndSomeSolverSettings(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), ConsoleUtils::outputOutputInformation(), FEProblemBase::outputStep(), FEProblemBase::subdomainSetup(), and FEProblemBase::timestepSetup().

{
  return _output_warehouse;
}

getParam() [1/2]

template<typename T >

const T & MooseApp::getParam

(

const std::string &

name

)

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 1465 of file MooseApp.h.

Referenced by CommonOutputAction::act(), FEProblemBase::addOutput(), Console::Console(), MooseApp(), PerfGraphOutput::output(), SetupMeshAction::setupMesh(), and Output::setWallTimeIntervalFromCommandLineParam().

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

getParam() [2/2]

template<typename T >

const T & MooseApp::getParam

(

const std::string &

name

)

const

Definition at line 1472 of file MooseApp.h.

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

getPrintableName()

virtual std::string MooseApp::getPrintableName ( ) const

inlinevirtual

Get printable name of the application.

Definition at line 107 of file MooseApp.h.

Referenced by getPrintableVersion().

{ return "Application"; }

getPrintableVersion()

std::string MooseApp::getPrintableVersion

(

)

const

Non-virtual method for printing out the version string in a consistent format.

Definition at line 682 of file MooseApp.C.

Referenced by setupOptions().

{
  return getPrintableName() + " Version: " + getVersion();
}

getRecoverableData()

const DataNames& MooseApp::getRecoverableData ( ) const

inline

Return a reference to the recoverable data object.

Returns

A const reference to the recoverable data

Definition at line 706 of file MooseApp.h.

Referenced by restore().

{ return _recoverable_data_names; }

getRecoverFileBase()

std::string MooseApp::getRecoverFileBase ( ) const

inline

Definition at line 487 of file MooseApp.h.

  {
    mooseDeprecated("MooseApp::getRecoverFileBase is deprecated, use "
                    "MooseApp::getRestartRecoverFileBase() instead.");
    return _restart_recover_base;
  }

getRelationshipManagerInfo()

std::vector< std::pair< std::string, std::string > > MooseApp::getRelationshipManagerInfo

(

)

const

Returns the Relationship managers info suitable for printing.

Definition at line 2674 of file MooseApp.C.

Referenced by ConsoleUtils::outputRelationshipManagerInformation().

{
  std::vector<std::pair<std::string, std::string>> info_strings;
  info_strings.reserve(_relationship_managers.size());

  for (const auto & rm : _relationship_managers)
  {
    std::stringstream oss;
    oss << rm->getInfo();

    auto & for_whom = rm->forWhom();

    if (!for_whom.empty())
    {
      oss << " for ";

      std::copy(for_whom.begin(), for_whom.end(), infix_ostream_iterator<std::string>(oss, ", "));
    }

    info_strings.emplace_back(std::make_pair(Moose::stringify(rm->getType()), oss.str()));
  }

  // List the libMesh GhostingFunctors - Not that in libMesh all of the algebraic and coupling
  // Ghosting Functors are also attached to the mesh. This should catch them all.
  const auto & mesh = _action_warehouse.getMesh();
  if (mesh)
  {
    // Let us use an ordered map to avoid stochastic console behaviors.
    // I believe we won't have many RMs, and there is no performance issue.
    // Deterministic behaviors are good for setting up regression tests
    std::map<std::string, unsigned int> counts;

    for (auto & gf : as_range(mesh->getMesh().ghosting_functors_begin(),
                              mesh->getMesh().ghosting_functors_end()))
    {
      const auto * gf_ptr = dynamic_cast<const RelationshipManager *>(gf);
      if (!gf_ptr)
        // Count how many occurences of the same Ghosting Functor types we are encountering
        counts[demangle(typeid(*gf).name())]++;
    }

    for (const auto & pair : counts)
      info_strings.emplace_back(std::make_pair(
          "Default", pair.first + (pair.second > 1 ? " x " + std::to_string(pair.second) : "")));
  }

  // List the libMesh GhostingFunctors - Not that in libMesh all of the algebraic and coupling
  // Ghosting Functors are also attached to the mesh. This should catch them all.
  const auto & d_mesh = _action_warehouse.getDisplacedMesh();
  if (d_mesh)
  {
    // Let us use an ordered map to avoid stochastic console behaviors.
    // I believe we won't have many RMs, and there is no performance issue.
    // Deterministic behaviors are good for setting up regression tests
    std::map<std::string, unsigned int> counts;

    for (auto & gf : as_range(d_mesh->getMesh().ghosting_functors_begin(),
                              d_mesh->getMesh().ghosting_functors_end()))
    {
      const auto * gf_ptr = dynamic_cast<const RelationshipManager *>(gf);
      if (!gf_ptr)
        // Count how many occurences of the same Ghosting Functor types we are encountering
        counts[demangle(typeid(*gf).name())]++;
    }

    for (const auto & pair : counts)
      info_strings.emplace_back(
          std::make_pair("Default",
                         pair.first + (pair.second > 1 ? " x " + std::to_string(pair.second) : "") +
                             " for DisplacedMesh"));
  }

  return info_strings;
}

getReleationshipManagers()

const std::vector<std::shared_ptr<RelationshipManager> >& MooseApp::getReleationshipManagers

(

)

Retrieve the relationship managers.

getRenamedParam()

template<typename T >

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

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 1479 of file MooseApp.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), this);
  // Second most: accept old parameter
  else if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), this);
  // 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), this);
  // 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 mispell 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() [1/2]

const std::vector<RestartableDataMap>& MooseApp::getRestartableData ( ) const

inline

Return reference to the restartable data object.

Returns

A reference to the restartable data object

Definition at line 672 of file MooseApp.h.

{ return _restartable_data; }

getRestartableData() [2/2]

std::vector<RestartableDataMap>& MooseApp::getRestartableData ( )

inline

Definition at line 673 of file MooseApp.h.

{ return _restartable_data; }

getRestartableDataMap()

RestartableDataMap & MooseApp::getRestartableDataMap

(

const RestartableDataMapName &

name

)

Return a reference to restartable data for the specific type flag.

Definition at line 2782 of file MooseApp.C.

Referenced by getRestartableMetaData(), possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

{
  auto iter = _restartable_meta_data.find(name);
  if (iter == _restartable_meta_data.end())
    mooseError("Unable to find RestartableDataMap object for the supplied name '",
               name,
               "', did you call registerRestartableDataMapName in the application constructor?");
  return iter->second.first;
}

getRestartableDataMapBegin()

auto MooseApp::getRestartableDataMapBegin ( )

inline

Iterator based access to the extra RestartableDataMap objects; see Checkpoint.C for use case.

These are MOOSE internal functions and should not be used otherwise.

Definition at line 1022 of file MooseApp.h.

Referenced by SetupDebugAction::act().

{ return _restartable_meta_data.begin(); }

getRestartableDataMapEnd()

auto MooseApp::getRestartableDataMapEnd ( )

inline

Definition at line 1024 of file MooseApp.h.

Referenced by SetupDebugAction::act().

{ return _restartable_meta_data.end(); }

getRestartableDataMapName()

const std::string & MooseApp::getRestartableDataMapName

(

const RestartableDataMapName &

name

)

const

Returns

The output name for the restartable data with name name

Definition at line 2809 of file MooseApp.C.

Referenced by possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

{
  const auto it = _restartable_meta_data.find(name);
  if (it == _restartable_meta_data.end())
    mooseError("MooseApp::getRestartableDataMapName: The name '", name, "' is not registered");
  return it->second.second;
}

getRestartableMetaData()

RestartableDataValue & MooseApp::getRestartableMetaData	(	const std::string &	name,
		const RestartableDataMapName &	metaname,
		THREAD_ID	tid
	)

Definition at line 1869 of file MooseApp.C.

Referenced by MeshMetaDataInterface::getMeshPropertyInternal(), and MeshGenerator::setMeshPropertyHelper().

{
  if (tid != 0)
    mooseError(
        "The meta data storage for '", metaname, "' is not threaded, so the tid must be zero.");

  // Get metadata reference from RestartableDataMap and return a (non-const) reference to its value
  auto & restartable_data_map = getRestartableDataMap(metaname);
  RestartableDataValue * const data = restartable_data_map.findData(name);
  if (!data)
    mooseError("Unable to find RestartableDataValue object with name " + name +
               " in RestartableDataMap");

  return *data;
}

getRestartRecoverFileBase()

std::string MooseApp::getRestartRecoverFileBase ( ) const

inline

The file_base for the recovery file.

Definition at line 486 of file MooseApp.h.

Referenced by SetupRecoverFileBaseAction::act(), MooseMesh::init(), and FEProblemBase::initialSetup().

{ return _restart_recover_base; }

getRMClone()

RelationshipManager & MooseApp::getRMClone ( const RelationshipManager &  template_rm, const MeshBase &  mesh  ) const

private

Return the relationship manager clone originally created from the provided template relationship manager and mesh.

Definition at line 2436 of file MooseApp.C.

Referenced by removeRelationshipManager().

{
  auto outer_it = _template_to_clones.find(&template_rm);
  if (outer_it == _template_to_clones.end())
    mooseError("The template rm does not exist in our _template_to_clones map");

  auto & mesh_to_clone_map = outer_it->second;
  auto inner_it = mesh_to_clone_map.find(&mesh);
  if (inner_it == mesh_to_clone_map.end())
    mooseError("We should have the mesh key in our mesh");

  return *inner_it->second;
}

getStartTime()

Real MooseApp::getStartTime ( ) const

inline

Returns

The start time

Definition at line 284 of file MooseApp.h.

Referenced by FEProblemBase::initialSetup(), and Transient::Transient().

{ return _start_time; }

getSystemInfo()

const SystemInfo* MooseApp::getSystemInfo ( ) const

inline

Get SystemInfo object.

Returns

A pointer to the SystemInformation object

Definition at line 546 of file MooseApp.h.

Referenced by ConsoleUtils::outputFrameworkInformation(), ExodusFormatter::printInputFile(), and to_json().

{ return _sys_info.get(); }

getVersion()

std::string MooseApp::getVersion ( ) const

virtual

Returns the current version of the framework or application (default: framework version).

Definition at line 676 of file MooseApp.C.

Referenced by getPrintableVersion().

{
  return MOOSE_VERSION;
}

hasInitialBackup()

bool MooseApp::hasInitialBackup ( ) const

inline

Returns

Whether or not this app currently has an "initial" backup

See _initial_backup and restoreFromInitialBackup() for more info.

Definition at line 990 of file MooseApp.h.

Referenced by FEProblemBase::initialSetup(), and restoreFromInitialBackup().

  {
    return _initial_backup != nullptr && *_initial_backup != nullptr;
  }

hasMeshGenerator()

bool MooseApp::hasMeshGenerator ( const MeshGeneratorName &  name ) const

inline

Returns

Whether or not a mesh generator exists with the name name.

Definition at line 841 of file MooseApp.h.

  {
    return _mesh_generator_system.hasMeshGenerator(name);
  }

hasOutputPosition()

bool MooseApp::hasOutputPosition ( ) const

inline

Whether or not an output position has been set.

Returns

True if it has

Definition at line 260 of file MooseApp.h.

Referenced by Exodus::output().

{ return _output_position_set; }

hasRecoverFileBase()

bool MooseApp::hasRecoverFileBase

(

)

const

Definition at line 1192 of file MooseApp.C.

{
  mooseDeprecated("MooseApp::hasRecoverFileBase is deprecated, use "
                  "MooseApp::hasRestartRecoverFileBase() instead.");
  return !_restart_recover_base.empty();
}

hasRelationshipManager()

bool MooseApp::hasRelationshipManager

(

const std::string &

name

)

const

Returns a Boolean indicating whether a RelationshipManater exists with the same name.

Definition at line 2323 of file MooseApp.C.

{
  return std::find_if(_relationship_managers.begin(),
                      _relationship_managers.end(),
                      [&name](const std::shared_ptr<RelationshipManager> & rm)
                      { return rm->name() == name; }) != _relationship_managers.end();
}

hasRestartableDataMap()

bool MooseApp::hasRestartableDataMap

(

const RestartableDataMapName &

name

)

const

Returns

Whether or not the restartable data has the given name registered.

Definition at line 2793 of file MooseApp.C.

{
  return _restartable_meta_data.count(name);
}

hasRestartableMetaData()

bool MooseApp::hasRestartableMetaData	(	const std::string &	name,
		const RestartableDataMapName &	metaname
	)		const

Definition at line 1859 of file MooseApp.C.

Referenced by MeshMetaDataInterface::hasMeshProperty().

{
  auto it = _restartable_meta_data.find(metaname);
  if (it == _restartable_meta_data.end())
    return false;
  return it->second.first.hasData(name);
}

hasRestartRecoverFileBase()

bool MooseApp::hasRestartRecoverFileBase

(

)

const

Return true if the recovery file base is set.

Definition at line 1186 of file MooseApp.C.

{
  return !_restart_recover_base.empty();
}

hasRMClone()

bool MooseApp::hasRMClone ( const RelationshipManager &  template_rm, const MeshBase &  mesh  ) const

private

Returns

whether we have created any clones for the provided template relationship manager and mesh yet. This may be false for instance when we are in the initial add relationship manager stage and haven't attempted attaching any relationship managers to the mesh or dof map yet (which is when we generate the clones). It's also maybe possible that we've created a clone of a given template_rm but not for the provided mesh so we return false in that case as well

Definition at line 2428 of file MooseApp.C.

Referenced by removeRelationshipManager().

{
  auto it = _template_to_clones.find(&template_rm);
  // C++ does short circuiting so we're safe here
  return (it != _template_to_clones.end()) && (it->second.find(&mesh) != it->second.end());
}

hasStartTime()

bool MooseApp::hasStartTime ( ) const

inline

Returns

Whether or not a start time has been programmatically set using setStartTime()

Definition at line 279 of file MooseApp.h.

Referenced by FEProblemBase::initialSetup(), and Transient::Transient().

{ return _start_time_set; }

header()

std::string MooseApp::header ( ) const

virtual

Returns a string to be printed at the beginning of a simulation.

Definition at line 2231 of file MooseApp.C.

Referenced by restore(), and setupOptions().

{
  return std::string("");
}

isParamSetByUser()

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

inline

Definition at line 165 of file MooseApp.h.

Referenced by getRenamedParam().

{ return _pars.isParamSetByUser(nm); }

isParamValid()

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

inline

Definition at line 163 of file MooseApp.h.

Referenced by copyInputs(), getRenamedParam(), MooseApp(), run(), runInputFile(), runInputs(), setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), and showInputs().

{ return _pars.isParamValid(name); }

isRecovering()

bool MooseApp::isRecovering

(

)

const

Whether or not this is a "recover" calculation.

More specifically whether this simulation has been recovered with something like the –recover command line argument. Note that this will never return true when isRestarting is true

Definition at line 1168 of file MooseApp.C.

Referenced by ExecuteMeshGenerators::act(), SetupMeshCompleteAction::act(), SetupMeshAction::act(), SetupRecoverFileBaseAction::act(), OversampleOutput::cloneMesh(), MultiApp::createApp(), NonlinearEigen::execute(), InversePowerMethod::execute(), Steady::execute(), Eigenvalue::execute(), NonlinearEigen::init(), InversePowerMethod::init(), Transient::init(), MooseMesh::init(), Console::initialSetup(), FEProblemBase::initialSetup(), OversampleOutput::outputStep(), Output::outputStep(), Transient::preExecute(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientMultiApp::solveStep(), and TimeExtremeValue::TimeExtremeValue().

{
  return _recover;
}

isRestarting()

bool MooseApp::isRestarting

(

)

const

Whether or not this is a "restart" calculation.

More specifically whether this has been restarted using the Problem/restart_file_base parameter. Note that this will only return true when doing checkpoint restart. This will be false if doing exodus restart. Finally this will never return true when isRecovering is true

Definition at line 1174 of file MooseApp.C.

Referenced by SetupMeshAction::act(), FEProblemBase::checkICRestartError(), MultiApp::createApp(), FileOutput::FileOutput(), FEProblemBase::initialSetup(), Transient::preExecute(), TimeSequenceStepperBase::setupSequence(), and TransientMultiApp::solveStep().

{
  return _restart;
}

isSplitMesh()

bool MooseApp::isSplitMesh

(

)

const

Whether or not this is a split mesh operation.

Definition at line 1180 of file MooseApp.C.

Referenced by MooseMesh::init().

{
  return _split_mesh;
}

isUltimateMaster()

bool MooseApp::isUltimateMaster ( ) const

inline

Whether or not this app is the ultimate master app.

(ie level == 0)

Definition at line 805 of file MooseApp.h.

Referenced by AutoCheckpointAction::act(), ExecuteMeshGenerators::act(), SetupMeshCompleteAction::act(), SetupMeshAction::act(), SetupRecoverFileBaseAction::act(), MooseBase::callMooseError(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), FixedPointSolve::FixedPointSolve(), MooseMesh::init(), FEProblemBase::initialSetup(), MooseApp(), Eigenvalue::prepareSolverOptions(), PerfGraphLivePrint::printStats(), setupOptions(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::~FEProblemBase().

{ return !_multiapp_level; }

libNameToAppName()

std::string MooseApp::libNameToAppName

(

const std::string &

library_name

)

const

Converts a library name to an application name:

Definition at line 1795 of file MooseApp.C.

{
  std::string app_name(library_name);

  // Strip off the leading "lib" and trailing ".la"
  if (pcrecpp::RE("lib(.+?)(?:-\\w+)?\\.la").Replace("\\1", &app_name) == 0)
    mooseError("Invalid library name: ", app_name);

  return MooseUtils::underscoreToCamelCase(app_name, true);
}

loadLibraryAndDependencies()

void MooseApp::loadLibraryAndDependencies ( const std::string &  library_filename, const Parameters &  params, bool  load_dependencies = true  )

protected

Recursively loads libraries and dependencies in the proper order to fully register a MOOSE application that may have several dependencies.

REQUIRES: dynamic linking loader support.

Definition at line 2038 of file MooseApp.C.

Referenced by dynamicRegistration().

{
  std::string line;
  std::string dl_lib_filename;

  // This RE looks for absolute path libtool filenames (i.e. begins with a slash and ends with a
  // .la)
  pcrecpp::RE re_deps("(/\\S*\\.la)");

  std::ifstream la_handle(library_filename.c_str());
  if (la_handle.is_open())
  {
    while (std::getline(la_handle, line))
    {
      // Look for the system dependent dynamic library filename to open
      if (line.find("dlname=") != std::string::npos)
        // Magic numbers are computed from length of this string "dlname=' and line minus that
        // string plus quotes"
        dl_lib_filename = line.substr(8, line.size() - 9);

      if (line.find("dependency_libs=") != std::string::npos)
      {
        if (load_dependencies)
        {
          pcrecpp::StringPiece input(line);
          pcrecpp::StringPiece depend_library;
          while (re_deps.FindAndConsume(&input, &depend_library))
            // Recurse here to load dependent libraries in depth-first order
            loadLibraryAndDependencies(depend_library.as_string(), params, load_dependencies);
        }

        // There's only one line in the .la file containing the dependency libs so break after
        // finding it
        break;
      }
    }
    la_handle.close();
  }

  // This should only occur if we have static linkage.
  if (dl_lib_filename.empty())
    return;

  const auto & [dir, file_name] = MooseUtils::splitFileName(library_filename);

  // Time to load the library, First see if we've already loaded this particular dynamic library
  //     1) make sure we haven't already loaded this library
  // AND 2) make sure we have a library name (we won't for static linkage)
  // Note: Here was are going to assume uniqueness based on the filename alone. This has significant
  // implications for applications that have "diamond" inheritance of libraries (usually
  // modules). We will only load one of those libraries, versions be damned.
  auto dyn_lib_it = _lib_handles.find(file_name);
  if (dyn_lib_it == _lib_handles.end())
  {
    // Assemble the actual filename using the base path of the *.la file and the dl_lib_filename
    const auto dl_lib_full_path = MooseUtils::pathjoin(dir, dl_lib_filename);

    MooseUtils::checkFileReadable(dl_lib_full_path, false, /*throw_on_unreadable=*/true);

#ifdef LIBMESH_HAVE_DLOPEN
    void * const lib_handle = dlopen(dl_lib_full_path.c_str(), RTLD_LAZY);
#else
    void * const lib_handle = nullptr;
#endif

    if (!lib_handle)
      mooseError("The library file \"",
                 dl_lib_full_path,
                 "\" exists and has proper permissions, but cannot by dynamically loaded.\nThis "
                 "generally means that the loader was unable to load one or more of the "
                 "dependencies listed in the supplied library (see otool or ldd).\n",
                 dlerror());

    DynamicLibraryInfo lib_info;
    lib_info.library_handle = lib_handle;
    lib_info.full_path = library_filename;

    auto insert_ret = _lib_handles.insert(std::make_pair(file_name, lib_info));
    mooseAssert(insert_ret.second == true, "Error inserting into lib_handles map");

    dyn_lib_it = insert_ret.first;
  }

  // Library has been loaded, check to see if we've called the requested registration method
  const auto registration_method = params.get<std::string>("registration_method");
  auto & entry_sym_from_curr_lib = dyn_lib_it->second.entry_symbols;

  if (entry_sym_from_curr_lib.find(registration_method) == entry_sym_from_curr_lib.end())
  {
    // get the pointer to the method in the library.  The dlsym()
    // function returns a null pointer if the symbol cannot be found,
    // we also explicitly set the pointer to NULL if dlsym is not
    // available.
#ifdef LIBMESH_HAVE_DLOPEN
    void * registration_handle =
        dlsym(dyn_lib_it->second.library_handle, registration_method.c_str());
#else
    void * registration_handle = nullptr;
#endif

    if (registration_handle)
    {
      switch (params.get<RegistrationType>("reg_type"))
      {
        case APPLICATION:
        {
          using register_app_t = void (*)();
          register_app_t * const reg_ptr = reinterpret_cast<register_app_t *>(&registration_handle);
          (*reg_ptr)();
          break;
        }
        case REGALL:
        {
          using register_app_t = void (*)(Factory *, ActionFactory *, Syntax *);
          register_app_t * const reg_ptr = reinterpret_cast<register_app_t *>(&registration_handle);
          (*reg_ptr)(params.get<Factory *>("factory"),
                     params.get<ActionFactory *>("action_factory"),
                     params.get<Syntax *>("syntax"));
          break;
        }
        default:
          mooseError("Unhandled RegistrationType");
      }

      entry_sym_from_curr_lib.insert(registration_method);
    }
    else
    {

#if defined(DEBUG) && defined(LIBMESH_HAVE_DLOPEN)
      // We found a dynamic library that doesn't have a dynamic
      // registration method in it. This shouldn't be an error, so
      // we'll just move on.
      if (!registration_handle)
        mooseWarning("Unable to find extern \"C\" method \"",
                     registration_method,
                     "\" in library: ",
                     dyn_lib_it->first,
                     ".\n",
                     "This doesn't necessarily indicate an error condition unless you believe that "
                     "the method should exist in that library.\n",
                     dlerror());
#endif
    }
  }
}

loadRestartableMetaData()

void MooseApp::loadRestartableMetaData

(

const std::filesystem::path &

folder_base

)

Loads all available restartable meta data if it is available with the folder base folder_base.

Definition at line 1903 of file MooseApp.C.

Referenced by SetupRecoverFileBaseAction::act().

{
  for (const auto & name_map_pair : _restartable_meta_data)
    possiblyLoadRestartableMetaData(name_map_pair.first, folder_base);
}

masterDisplacedMesh()

const MooseMesh* MooseApp::masterDisplacedMesh ( ) const

inline

Returns a pointer to the master displaced mesh.

Definition at line 815 of file MooseApp.h.

Referenced by SetupMeshAction::act().

{ return _master_displaced_mesh; }

masterMesh()

const MooseMesh* MooseApp::masterMesh ( ) const

inline

Returns a pointer to the master mesh.

Definition at line 810 of file MooseApp.h.

Referenced by ExecuteMeshGenerators::act(), SetupMeshCompleteAction::act(), and SetupMeshAction::act().

{ return _master_mesh; }

metaDataFolderBase()

std::filesystem::path MooseApp::metaDataFolderBase ( const std::filesystem::path &  folder_base, const std::string &  map_suffix  )

static

The file suffix for meta data (header and data)

Definition at line 2404 of file MooseApp.C.

Referenced by possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

{
  return RestartableDataIO::restartableDataFolder(folder_base /
                                                  std::filesystem::path("meta_data" + map_suffix));
}

multiAppLevel()

unsigned int MooseApp::multiAppLevel ( ) const

inline

The MultiApp Level.

Returns

The current number of levels from the master app

Definition at line 794 of file MooseApp.h.

Referenced by FEProblemBase::checkNonlinearConvergence(), MultiApp::createApp(), OutputWarehouse::mooseConsole(), setupOptions(), and Console::write().

{ return _multiapp_level; }

multiAppNumber()

unsigned int MooseApp::multiAppNumber ( ) const

inline

The MultiApp number.

Returns

The numbering in all the sub-apps on the same level

Definition at line 800 of file MooseApp.h.

Referenced by FileOutput::FileOutput(), and Console::outputSystemInformation().

{ return _multiapp_number; }

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.

Referenced by HierarchicalGridPartitioner::_do_partition(), CopyNodalVarsAction::act(), AddElementalFieldAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), DeprecatedBlockAction::act(), DisplayGhostingAction::act(), AddVariableAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), addExecutor(), addExecutorParams(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), SubProblem::addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), AuxKernelTempl< Real >::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), UserObject::addVectorPostprocessorDependencyHelper(), FVFluxKernel::adjustRMGhostLayers(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), appBinaryName(), appendMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), AStableDirk4::AStableDirk4(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), MultiApp::backup(), Moose::Builder::build(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), PiecewiseTabularBase::buildFromFile(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), FEProblemBase::checkDependMaterialsHelper(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Material::checkMaterialProperty(), checkMetaDataIntegrity(), Damper::checkMinDamping(), FEProblemBase::checkNonlinearConvergence(), Coupleable::checkWritableVar(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBaseParameterInterface::connectControllableParams(), MultiApp::createApp(), createExecutors(), AddVariableAction::createInitialConditionAction(), MultiApp::createLocalApp(), MeshGeneratorSystem::createMeshGeneratorOrder(), createRecoverablePerfGraph(), MaterialBase::declareADProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), MooseBase::errorPrefix(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), RestartableDataReporter::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), MultiApp::fillPositions(), PointSamplerBase::finalize(), FunctionDT::FunctionDT(), FVFunctionIC::functionName(), FunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), StitchedMeshGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), UserObject::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), SolutionUserObject::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), ActionWarehouse::getMooseAppName(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ReporterData::getReporterInfo(), getRestartableDataMap(), getRestartableDataMapName(), getRestartableMetaData(), FEProblemBase::getSampler(), Transient::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), hasMeshGenerator(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), hasRelationshipManager(), hasRestartableDataMap(), hasRestartableMetaData(), FEProblemBase::hasUserObject(), IterationAdaptiveDT::init(), AdvancedOutput::init(), FEProblemBase::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), SolutionUserObject::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MeshGenerator::isChildMeshGenerator(), MeshGenerator::isNullMeshName(), isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), Marker::Marker(), MatDiffusionBase< Real >::MatDiffusionBase(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshGenerator::meshPropertyPrefix(), MooseApp(), OutputWarehouse::mooseConsole(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), PhysicsBase::nonlinearVariableExists(), Registry::objData(), MeshGenerator::Comparator::operator()(), ProgressOutput::output(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), Nemesis::outputPostprocessors(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedAux::ParsedAux(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedGenerateSideset::ParsedGenerateSideset(), MooseServer::parseDocumentForDiagnostics(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PointVariableSamplerBase::PointVariableSamplerBase(), possiblyLoadRestartableMetaData(), PhysicsBase::prefix(), PerfGraphLivePrint::printStats(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), registerRestartableDataMapName(), registerRestartableNameWithFilter(), GlobalParamsAction::remove(), MaterialBase::resetQpProperties(), MultiApp::restore(), runInputFile(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), GlobalParamsAction::setDoubleIndexParam(), OutputWarehouse::setFileNumbers(), GlobalParamsAction::setParam(), FEProblemBase::setPostprocessorValueByName(), GlobalParamsAction::setScalarParam(), MooseMesh::setSubdomainName(), GlobalParamsAction::setTripleIndexParam(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), GlobalParamsAction::setVectorParam(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SideValueSampler::SideValueSampler(), TransientMultiApp::solveStep(), UserObject::spatialValue(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), SubProblem::storeSubdomainZeroMatProp(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), VectorPostprocessorVisualizationAux::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBaseParameterInterface::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObject::UserObject(), UserObjectInterface::userObjectName(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and writeRestartableMetaData().

{ return _name; }

parameters()

InputParameters& MooseApp::parameters ( )

inline

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 122 of file MooseApp.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), CommonOutputAction::act(), MeshGeneratorSystem::hasDataDrivenAllowed(), MooseApp(), ConsoleUtils::outputLegacyInformation(), MooseServer::parseDocumentForDiagnostics(), and NonlinearSystemBase::shouldEvaluatePreSMOResidual().

{ return _pars; }

parser()

Parser & MooseApp::parser

(

)

Returns

The Parser

Definition at line 1353 of file MooseApp.C.

Referenced by ActionFactory::create().

{
  mooseAssert(_parser, "Not set");
  return *_parser;
}

perfGraph()

PerfGraph& MooseApp::perfGraph ( )

inline

Get the PerfGraph for this app.

Definition at line 133 of file MooseApp.h.

Referenced by PerfGraphInterface::perfGraph().

{ return _perf_graph; }

possiblyLoadRestartableMetaData()

void MooseApp::possiblyLoadRestartableMetaData	(	const RestartableDataMapName &	name,
		const std::filesystem::path &	folder_base
	)

Loads the restartable meta data for name if it is available with the folder base folder_base.

Definition at line 1888 of file MooseApp.C.

Referenced by FileMesh::buildMesh(), FileMeshGenerator::generate(), and loadRestartableMetaData().

{
  const auto & map_name = getRestartableDataMapName(name);
  const auto meta_data_folder_base = metaDataFolderBase(folder_base, map_name);
  if (RestartableDataReader::isAvailable(meta_data_folder_base))
  {
    RestartableDataReader reader(*this, getRestartableDataMap(name));
    reader.setErrorOnLoadWithDifferentNumberOfProcessors(false);
    reader.setInput(meta_data_folder_base);
    reader.restore();
  }
}

postRestore()

virtual void MooseApp::postRestore ( const bool  )

inlinevirtual

Insertion point for other apps that is called after restore()

Parameters

for_restart

Whether this restoration is explicitly for the first restoration of restart data

Definition at line 758 of file MooseApp.h.

Referenced by restore().

{}

preBackup()

virtual void MooseApp::preBackup ( )

inlinevirtual

Insertion point for other apps that is called before backup()

Definition at line 724 of file MooseApp.h.

Referenced by backup().

{}

processor_id()

processor_id_type MooseApp::processor_id ( ) const

inline

Returns the MPI processor ID of the current processor.

Definition at line 406 of file MooseApp.h.

Referenced by copyInputs(), MooseApp(), restartFolderBase(), runInputs(), FileOutput::setFileBaseInternal(), and writeRestartableMetaData().

{ return _comm->rank(); }

rankMap()

const RankMap& MooseApp::rankMap ( )

inline

The RankMap is a useful object for determining how the processes are laid out on the physical nodes of the cluster.

Definition at line 128 of file MooseApp.h.

{ return _rank_map; }

recursivelyCreateExecutors()

void MooseApp::recursivelyCreateExecutors ( const std::string &  current_executor_name, std::list< std::string > &  possible_roots, std::list< std::string > &  current_branch  )

private

Internal function used to recursively create the executor objects.

Called by createExecutors

Parameters

current_executor_name	The name of the executor currently needing to be built
possible_roots	The names of executors that are currently candidates for being the root

Definition at line 1360 of file MooseApp.C.

Referenced by createExecutors().

{
  // Did we already make this one?
  if (_executors.find(current_executor_name) != _executors.end())
    return;

  // Is this one already on the current branch (i.e. there is a cycle)
  if (std::find(current_branch.begin(), current_branch.end(), current_executor_name) !=
      current_branch.end())
  {
    std::stringstream exec_names_string;

    auto branch_it = current_branch.begin();

    exec_names_string << *branch_it++;

    for (; branch_it != current_branch.end(); ++branch_it)
      exec_names_string << ", " << *branch_it;

    exec_names_string << ", " << current_executor_name;

    mooseError("Executor cycle detected: ", exec_names_string.str());
  }

  current_branch.push_back(current_executor_name);

  // Build the dependencies first
  const auto & params = *_executor_params[current_executor_name].second;

  for (const auto & param : params)
  {
    if (params.have_parameter<ExecutorName>(param.first))
    {
      const auto & dependency_name = params.get<ExecutorName>(param.first);

      possible_roots.remove(dependency_name);

      if (!dependency_name.empty())
        recursivelyCreateExecutors(dependency_name, possible_roots, current_branch);
    }
  }

  // Add this Executor
  const auto & type = _executor_params[current_executor_name].first;
  addExecutor(type, current_executor_name, params);

  current_branch.pop_back();
}

registerInterfaceObject()

template<class T >

void MooseApp::registerInterfaceObject

(

T &

interface

)

Registers an interface object for accessing with getInterfaceObjects.

This should be called within the constructor of the interface in interest.

Definition at line 1504 of file MooseApp.h.

Referenced by Coupleable::Coupleable(), MaterialPropertyInterface::MaterialPropertyInterface(), PetscOutputInterface::PetscOutputInterface(), and Reporter::Reporter().

{
  static_assert(!std::is_base_of<MooseObject, T>::value, "T is not an interface");

  InterfaceRegistryObjects<T> * registry = nullptr;
  auto it = _interface_registry.find(typeid(T));
  if (it == _interface_registry.end())
  {
    auto new_registry = std::make_unique<InterfaceRegistryObjects<T>>();
    registry = new_registry.get();
    _interface_registry.emplace(typeid(T), std::move(new_registry));
  }
  else
    registry = static_cast<InterfaceRegistryObjects<T> *>(it->second.get());

  mooseAssert(std::count(registry->_objects.begin(), registry->_objects.end(), &interface) == 0,
              "Interface already registered");
  registry->_objects.push_back(&interface);
}

registerRestartableData() [1/2]

RestartableDataValue & MooseApp::registerRestartableData	(	std::unique_ptr< RestartableDataValue >	data,
		THREAD_ID	tid,
		bool	read_only,
		const RestartableDataMapName &	metaname = ""
	)

Definition at line 1807 of file MooseApp.C.

Referenced by createRecoverablePerfGraph(), createRecoverableSolutionInvalidity(), MeshGenerator::declareMeshProperty(), ReporterData::getRestartableDataHelper(), and Restartable::registerRestartableDataOnApp().

{
  if (!metaname.empty() && tid != 0)
    mooseError(
        "The meta data storage for '", metaname, "' is not threaded, so the tid must be zero.");

  mooseAssert(metaname.empty() ||
                  _restartable_meta_data.find(metaname) != _restartable_meta_data.end(),
              "The desired meta data name does not exist: " + metaname);

  // Select the data store for saving this piece of restartable data (mesh or everything else)
  auto & data_map =
      metaname.empty() ? _restartable_data[tid] : _restartable_meta_data[metaname].first;

  RestartableDataValue * stored_data = data_map.findData(data->name());
  if (stored_data)
  {
    if (data->typeId() != stored_data->typeId())
      mooseError("Type mismatch found in RestartableData registration of '",
                 data->name(),
                 "'\n\n  Stored type: ",
                 stored_data->type(),
                 "\n  New type: ",
                 data->type());
  }
  else
    stored_data = &data_map.addData(std::move(data));

  if (!read_only)
    stored_data->setDeclared({});

  return *stored_data;
}

registerRestartableData() [2/2]

RestartableDataValue& MooseApp::registerRestartableData	(	const std::string &	name,
		std::unique_ptr< RestartableDataValue >	data,
		THREAD_ID	tid,
		bool	read_only,
		const RestartableDataMapName &	metaname = ""
	)

registerRestartableDataMapName()

void MooseApp::registerRestartableDataMapName	(	const RestartableDataMapName &	name,
		std::string	suffix = ""
	)

Reserve a location for storing custom RestartableDataMap objects.

This should be called in the constructor of an application.

Parameters

name	A key to use for accessing the data object
suffix	The suffix to use when appending to checkpoint output, if not supplied the given name is used to generate the suffix (MyMetaData -> _mymetadata)

Definition at line 2799 of file MooseApp.C.

Referenced by MooseApp().

{
  if (!suffix.empty())
    std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
  suffix.insert(0, "_");
  _restartable_meta_data.emplace(
      std::make_pair(name, std::make_pair(RestartableDataMap(), suffix)));
}

registerRestartableNameWithFilter()

void MooseApp::registerRestartableNameWithFilter ( const std::string &  name, Moose::RESTARTABLE_FILTER  filter  )

protected

NOTE: This is an internal function meant for MOOSE use only!

Register a piece of restartable data that will be used in a filter in/out during deserialization. Note however that this data will always be written to the restart file.

Parameters

name	The full (unique) name.
filter	The filter name where to direct the name

Definition at line 1200 of file MooseApp.C.

Referenced by createRecoverablePerfGraph(), createRecoverableSolutionInvalidity(), and Restartable::registerRestartableNameWithFilterOnApp().

{
  using Moose::RESTARTABLE_FILTER;
  switch (filter)
  {
    case RESTARTABLE_FILTER::RECOVERABLE:
      _recoverable_data_names.insert(name);
      break;
    default:
      mooseError("Unknown filter");
  }
}

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

relationshipManagers()

const std::set<std::shared_ptr<RelationshipManager> >& MooseApp::relationshipManagers ( ) const

inline

Return the container of relationship managers.

Definition at line 1006 of file MooseApp.h.

Referenced by NumRelationshipManagers::getValue().

  {
    return _relationship_managers;
  }

removeRelationshipManager()

void MooseApp::removeRelationshipManager ( std::shared_ptr< RelationshipManager >  relationship_manager )

private

Purge this relationship manager from meshes and DofMaps and finally from us.

This method is private because only this object knows when we should remove relationship managers: when we are adding relationship managers to this object's storage, we perform an operator>= comparison between our existing RMs and the RM we are trying to add. If any comparison returns true, we do not add the new RM because the comparison indicates that we would gain no new coverage. However, if no comparison return true, then we add the new RM and we turn the comparison around! Consequently if our new RM is >= than any of our preexisting RMs, we remove those preexisting RMs using this method

Definition at line 2451 of file MooseApp.C.

Referenced by addRelationshipManager().

{
  auto * const mesh = _action_warehouse.mesh().get();
  if (!mesh)
    mooseError("The MooseMesh should exist");

  const MeshBase * const undisp_lm_mesh = mesh->getMeshPtr();
  RelationshipManager * undisp_clone = nullptr;
  if (undisp_lm_mesh && hasRMClone(*rm, *undisp_lm_mesh))
  {
    undisp_clone = &getRMClone(*rm, *undisp_lm_mesh);
    const_cast<MeshBase *>(undisp_lm_mesh)->remove_ghosting_functor(*undisp_clone);
  }

  auto & displaced_mesh = _action_warehouse.displacedMesh();
  MeshBase * const disp_lm_mesh = displaced_mesh ? &displaced_mesh->getMesh() : nullptr;
  RelationshipManager * disp_clone = nullptr;
  if (disp_lm_mesh && hasRMClone(*rm, *disp_lm_mesh))
  {
    disp_clone = &getRMClone(*rm, *disp_lm_mesh);
    disp_lm_mesh->remove_ghosting_functor(*disp_clone);
  }

  if (_executioner)
  {
    auto & problem = feProblem();
    if (undisp_clone)
    {
      problem.removeAlgebraicGhostingFunctor(*undisp_clone);
      problem.removeCouplingGhostingFunctor(*undisp_clone);
    }

    auto * dp = problem.getDisplacedProblem().get();
    if (dp && disp_clone)
      dp->removeAlgebraicGhostingFunctor(*disp_clone);
  }

  _factory.releaseSharedObjects(*rm);
  _relationship_managers.erase(rm);
}

restartFolderBase()

std::filesystem::path MooseApp::restartFolderBase

(

const std::filesystem::path &

folder_base

)

const

The file suffix for restartable data.

Definition at line 2412 of file MooseApp.C.

Referenced by FEProblemBase::initialSetup(), and Checkpoint::output().

{
  auto folder = folder_base;
  folder += "-restart-" + std::to_string(processor_id());
  return RestartableDataIO::restartableDataFolder(folder);
}

restore() [1/2]

void MooseApp::restore	(	const std::filesystem::path &	folder_base,
		const bool	for_restart
	)

Restore an application from file.

Parameters

folder_base	The backup folder base
for_restart	Whether this restoration is explicitly for the first restoration of restart data

You must call finalizeRestore() after this in order to finalize the restoration. The restore process is kept open in order to restore additional data after the initial restore (that is, the restoration of data that has already been declared).

Definition at line 1241 of file MooseApp.C.

Referenced by FEProblemBase::initialSetup(), and restoreFromInitialBackup().

{
  TIME_SECTION("restore", 2, "Restoring Application from File");

  const DataNames filter_names = for_restart ? getRecoverableData() : DataNames{};

  _rd_reader.setInput(folder_base);
  _rd_reader.restore(filter_names);

  postRestore(for_restart);
}

restore() [2/2]

void MooseApp::restore	(	std::unique_ptr< Backup >	backup,
		const bool	for_restart
	)

Restore an application from the backup backup.

Parameters

backup	The backup
for_restart	Whether this restoration is explicitly for the first restoration of restart data

You must call finalizeRestore() after this in order to finalize the restoration. The restore process is kept open in order to restore additional data after the initial restore (that is, the restoration of data that has already been declared).

Definition at line 1254 of file MooseApp.C.

{
  TIME_SECTION("restore", 2, "Restoring Application");

  const DataNames filter_names = for_restart ? getRecoverableData() : DataNames{};

  if (!backup)
    mooseError("MooseApp::resore(): Provided backup is not initialized");

  auto header = std::move(backup->header);
  mooseAssert(header, "Header not available");

  auto data = std::move(backup->data);
  mooseAssert(data, "Data not available");

  _rd_reader.setInput(std::move(header), std::move(data));
  _rd_reader.restore(filter_names);

  postRestore(for_restart);
}

restoreFromInitialBackup()

void MooseApp::restoreFromInitialBackup

(

const bool

for_restart

)

Restores from a "initial" backup, that is, one set in _initial_backup.

Parameters

for_restart

Whether this restoration is explicitly for the first restoration of restart data

This is only used for restoration of multiapp subapps, which have been given a Backup from their parent on initialization. Said Backup is passed to this app via the "_initial_backup" private input parameter.

See restore() for more information

Definition at line 1276 of file MooseApp.C.

Referenced by FEProblemBase::initialSetup().

{
  mooseAssert(hasInitialBackup(), "Missing initial backup");
  restore(std::move(*_initial_backup), for_restart);
}

run()

void MooseApp::run ( )

virtual

Run the application.

Definition at line 1495 of file MooseApp.C.

{
  TIME_SECTION("run", 3);
  if (isParamValid("show_docs") && getParam<bool>("show_docs"))
  {
    auto binname = appBinaryName();
    if (binname == "")
      mooseError("could not locate installed tests to run (unresolved binary/app name)");
    auto docspath = MooseUtils::docsDir(binname);
    if (docspath == "")
      mooseError("no installed documentation found");

    auto docmsgfile = MooseUtils::pathjoin(docspath, "docmsg.txt");
    std::string docmsg = "file://" + MooseUtils::realpath(docspath) + "/index.html";
    if (MooseUtils::pathExists(docmsgfile) && MooseUtils::checkFileReadable(docmsgfile))
    {
      std::ifstream ifs(docmsgfile);
      std::string content((std::istreambuf_iterator<char>(ifs)),
                          (std::istreambuf_iterator<char>()));
      content.replace(content.find("$LOCAL_SITE_HOME"), content.length(), docmsg);
      docmsg = content;
    }

    Moose::out << docmsg << "\n";
    _ready_to_exit = true;
    return;
  }

  if (showInputs() || copyInputs() || runInputs())
  {
    _ready_to_exit = true;
    return;
  }

  try
  {
    TIME_SECTION("setup", 2, "Setting Up");
    setupOptions();
    runInputFile();
  }
  catch (std::exception & err)
  {
    mooseError(err.what());
  }

  if (!_check_input)
  {
    TIME_SECTION("execute", 2, "Executing");
    executeExecutioner();
  }
  else
  {
    errorCheck();
    // Output to stderr, so it is easier for peacock to get the result
    Moose::err << "Syntax OK" << std::endl;
  }
}

runInputFile()

void MooseApp::runInputFile ( )

virtual

Actually build everything in the input file.

Definition at line 1098 of file MooseApp.C.

Referenced by run().

{
  TIME_SECTION("runInputFile", 3);

  // If ready to exit has been set, then just return
  if (_ready_to_exit)
    return;

  _action_warehouse.executeAllActions();

  if (isParamValid("mesh_only") || isParamValid("split_mesh"))
    _ready_to_exit = true;
  else if (getParam<bool>("list_constructed_objects"))
  {
    // TODO: ask multiapps for their constructed objects
    _ready_to_exit = true;
    std::vector<std::string> obj_list = _factory.getConstructedObjects();
    Moose::out << "**START OBJECT DATA**\n";
    for (const auto & name : obj_list)
      Moose::out << name << "\n";
    Moose::out << "**END OBJECT DATA**\n" << std::endl;
  }
}

runInputs()

bool MooseApp::runInputs ( ) const

private

Handles the run input parameter logic: Checks to see whether a directory exists in user space and launches the TestHarness to process the given directory.

Returns

a Boolean value used to indicate whether the application should exit early

Definition at line 1655 of file MooseApp.C.

Referenced by run().

{
  if (isParamValid("run"))
  {
    // Here we are going to pass everything after --run on the cli to the TestHarness. That means
    // cannot validate these CLIs.
    auto it = _command_line->find("run");

    std::string test_args;
    if (it != _command_line->end())
    {
      // Preincrement here to skip over --run
      while (++it != _command_line->end())
        test_args += " " + *it;
    }

    auto cmd = MooseUtils::runTestsExecutable() + test_args;
    auto working_dir = MooseUtils::getCurrentWorkingDir();

    if (MooseUtils::findTestRoot() == "")
    {
      auto bin_name = appBinaryName();
      if (bin_name == "")
        mooseError("Could not locate binary name relative to installed location");

      auto cmd_name = Moose::getExecutableName();
      mooseError(
          "Could not locate installed tests from the current working directory:",
          working_dir,
          ".\nMake sure you are executing this command from within a writable installed inputs ",
          "directory.\nRun \"",
          cmd_name,
          " --copy-inputs <dir>\" to copy the contents of <dir> to a \"./",
          bin_name,
          "_<dir>\" directory.\nChange into that directory and try \"",
          cmd_name,
          " --run <dir>\" again.");
    }

    // Only launch the tests on the root processor
    Moose::out << "Working Directory: " << working_dir << "\nRunning Command: " << cmd << std::endl;
    int return_value = 0;
    if (processor_id() == 0)
      return_value = system(cmd.c_str());
    _communicator.broadcast(return_value);

    if (WIFEXITED(return_value) && WEXITSTATUS(return_value) != 0)
      mooseError("Run failed");
    return true;
  }

  return false;
}

setCheckUnusedFlag()

void MooseApp::setCheckUnusedFlag ( bool  warn_is_error = false )

private

Set a flag so that the parser will either warn or error when unused variables are seen after parsing is complete.

Definition at line 1315 of file MooseApp.C.

Referenced by setupOptions().

{
  _enable_unused_check = warn_is_error ? ERROR_UNUSED : WARN_UNUSED;
}

setErrorOverridden()

void MooseApp::setErrorOverridden

(

)

Set a flag so that the parser will throw an error if overridden parameters are detected.

Definition at line 1489 of file MooseApp.C.

Referenced by setupOptions().

{
  _error_overridden = true;
}

setExecutioner()

void MooseApp::setExecutioner ( std::shared_ptr< Executioner > &&  executioner )

inline

Set the Executioner for this App.

Definition at line 327 of file MooseApp.h.

Referenced by CreateExecutionerAction::act().

{ _executioner = executioner; }

setExecutor()

void MooseApp::setExecutor ( std::shared_ptr< Executor > &&  executor )

inline

Definition at line 328 of file MooseApp.h.

{ _executor = executor; }

setExodusFileRestart()

void MooseApp::setExodusFileRestart ( bool  flag )

inline

Set the flag to indicate whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh.

Definition at line 419 of file MooseApp.h.

Referenced by CopyNodalVarsAction::act(), and PhysicsBase::prepareCopyNodalVariables().

{ _initial_from_file = flag; }

setExReaderForRestart()

void MooseApp::setExReaderForRestart ( std::shared_ptr< ExodusII_IO > &&  exreader )

inline

Set the Exodus reader to restart variables from an Exodus mesh file.

Definition at line 430 of file MooseApp.h.

Referenced by FileMesh::buildMesh(), and FileMeshGenerator::generate().

{ _ex_reader = exreader; }

setGlobalTimeOffset()

void MooseApp::setGlobalTimeOffset ( Real  offset )

inline

Each App has it's own local time.

The "global" time of the whole problem might be different. This offset is how far off the local App time is from the global time.

Definition at line 290 of file MooseApp.h.

{ _global_time_offset = offset; }

setOutputFileBase()

void MooseApp::setOutputFileBase

(

const std::string &

output_file_base

)

Override the selection of the output file base name.

Note: This method is supposed to be called by MultiApp only.

Definition at line 1082 of file MooseApp.C.

{
  _output_file_base = output_file_base;

  // Reset the file base in the outputs
  _output_warehouse.resetFileBase();

  // Reset the file base in multiapps (if they have been constructed yet)
  if (getExecutioner())
    for (auto & multi_app : feProblem().getMultiAppWarehouse().getObjects())
      multi_app->setAppOutputFileBase();

  _file_base_set_by_user = true;
}

setOutputFileNumbers()

void MooseApp::setOutputFileNumbers ( const std::map< std::string, unsigned int > &  numbers )

inline

Store a map of outputter names and file numbers The MultiApp system requires this to get the file numbering to propagate down through the Multiapps.

Parameters

numbers

Map of outputter names and file numbers

See also

MultiApp TransientMultiApp OutputWarehouse

Definition at line 520 of file MooseApp.h.

  {
    _output_file_numbers = numbers;
  }

setOutputPosition()

void MooseApp::setOutputPosition

(

const Point &

p

)

Tell the app to output in a specific position.

Definition at line 1710 of file MooseApp.C.

{
  _output_position_set = true;
  _output_position = p;
  _output_warehouse.meshChanged();

  if (_executioner.get())
    _executioner->parentOutputPositionChanged();
}

setRecover()

void MooseApp::setRecover

(

bool

value

)

Definition at line 2243 of file MooseApp.C.

{
  _recover = value;
}

setRestart()

void MooseApp::setRestart

(

bool

value

)

Sets the restart/recover flags.

Parameters

state

The state to set the flag to

Definition at line 2237 of file MooseApp.C.

Referenced by FEProblemBase::setRestartFile().

{
  _restart = value;
}

setRestartRecoverFileBase()

void MooseApp::setRestartRecoverFileBase ( const std::string &  file_base )

inline

mutator for recover_base (set by RecoverBaseAction)

Definition at line 498 of file MooseApp.h.

Referenced by SetupRecoverFileBaseAction::act(), and FEProblemBase::setRestartFile().

  {
    if (file_base.empty())
      _restart_recover_base = MooseUtils::getLatestCheckpointFilePrefix(getCheckpointFiles());
    else
      _restart_recover_base = file_base;
  }

setStartTime()

void MooseApp::setStartTime

(

Real

time

)

Set the starting time for the simulation.

This will override any choice made in the input file.

Parameters

time	The start time for the simulation.

Definition at line 1760 of file MooseApp.C.

Referenced by EigenExecutionerBase::EigenExecutionerBase(), and Transient::Transient().

{
  _start_time_set = true;
  _start_time = time;
}

setupOptions()

void MooseApp::setupOptions ( )

virtual

Setup options based on InputParameters.

Definition at line 688 of file MooseApp.C.

Referenced by run().

{
  TIME_SECTION("setupOptions", 5, "Setting Up Options");

  // Print the header, this is as early as possible
  auto hdr = header();
  if (hdr.length() != 0)
  {
    if (multiAppLevel() > 0)
      MooseUtils::indentMessage(_name, hdr);
    Moose::out << hdr << std::endl;
  }

  if (getParam<bool>("error_unused"))
    setCheckUnusedFlag(true);
  else if (getParam<bool>("allow_unused"))
    setCheckUnusedFlag(false);

  if (getParam<bool>("error_override"))
    setErrorOverridden();

  _distributed_mesh_on_command_line = getParam<bool>("distributed_mesh");

  _test_checkpoint_half_transient = getParam<bool>("test_checkpoint_half_transient");

  if (isParamValid("output_wall_time_interval"))
  {
    const auto output_wall_time_interval = getParam<Real>("output_wall_time_interval");
    if (output_wall_time_interval <= 0)
      mooseError("--output-wall-time-interval must be greater than zero.");
  }

  // The no_timing flag takes precedence over the timing flag.
  if (getParam<bool>("no_timing"))
  {
    _pars.set<bool>("timing") = false;

    _perf_graph.setActive(false);
  }

  if (isParamValid("trap_fpe") && isParamValid("no_trap_fpe"))
    mooseError("Cannot use both \"--trap-fpe\" and \"--no-trap-fpe\" flags.");
  if (isParamValid("trap_fpe"))
    _trap_fpe = true;
  else if (isParamValid("no_trap_fpe"))
    _trap_fpe = false;

  // Turn all warnings in MOOSE to errors (almost see next logic block)
  Moose::_warnings_are_errors = getParam<bool>("error");

  // Deprecated messages can be toggled to errors independently from everything else.
  Moose::_deprecated_is_error = getParam<bool>("error_deprecated");

  if (isUltimateMaster()) // makes sure coloring isn't reset incorrectly in multi-app settings
  {
    // Toggle the color console off
    Moose::setColorConsole(true, true); // set default color condition
    if (getParam<bool>("no_color"))
      Moose::setColorConsole(false);

    char * c_color = std::getenv("MOOSE_COLOR");
    std::string color = "on";
    if (c_color)
      color = c_color;
    if (getParam<std::string>("color") != "default-on")
      color = getParam<std::string>("color");

    if (color == "auto")
      Moose::setColorConsole(true);
    else if (color == "on")
      Moose::setColorConsole(true, true);
    else if (color == "off")
      Moose::setColorConsole(false);
    else
      mooseWarning("ignoring invalid --color arg (want 'auto', 'on', or 'off')");
  }

  // this warning goes below --color processing to honor that setting for
  // the warning. And below settings for warnings/error setup.
  if (getParam<bool>("no_color"))
    mooseDeprecated("The --no-color flag is deprecated. Use '--color off' instead.");

// If there's no threading model active, but the user asked for
// --n-threads > 1 on the command line, throw a mooseError.  This is
// intended to prevent situations where the user has potentially
// built MOOSE incorrectly (neither TBB nor pthreads found) and is
// asking for multiple threads, not knowing that there will never be
// any threads launched.
#if !LIBMESH_USING_THREADS
  if (libMesh::command_line_value("--n-threads", 1) > 1)
    mooseError("You specified --n-threads > 1, but there is no threading model active!");
#endif

  // Build a minimal running application, ignoring the input file.
  if (getParam<bool>("minimal"))
    createMinimalApp();

  else if (getParam<bool>("display_version"))
  {
    Moose::out << getPrintableVersion() << std::endl;
    _ready_to_exit = true;
    return;
  }
  else if (getParam<bool>("help"))
  {
    _command_line->printUsage();
    _ready_to_exit = true;
  }
  else if (isParamValid("dump"))
  {
    // Get command line argument following --dump on command line
    std::string following_arg = getParam<std::string>("dump");

    // The argument following --dump is a parameter search string,
    // which can be empty.
    std::string param_search;
    if (!following_arg.empty() && (following_arg.find('-') != 0))
      param_search = following_arg;

    JsonSyntaxTree tree(param_search);

    {
      TIME_SECTION("dump", 1, "Building Syntax Tree");
      _builder.buildJsonSyntaxTree(tree);
    }

    // Turn off live printing so that it doesn't mess with the dump
    _perf_graph.disableLivePrint();

    JsonInputFileFormatter formatter;
    Moose::out << "\n### START DUMP DATA ###\n"
               << formatter.toString(tree.getRoot()) << "\n### END DUMP DATA ###" << std::endl;
    _ready_to_exit = true;
  }
  else if (isParamValid("registry"))
  {
    _perf_graph.disableLivePrint();

    Moose::out << "Label\tType\tName\tClass\tFile\n";

    auto & objmap = Registry::allObjects();
    for (auto & entry : objmap)
      for (auto & obj : entry.second)
        Moose::out << entry.first << "\tobject\t" << obj->name() << "\t" << obj->_classname << "\t"
                   << obj->_file << "\n";

    auto & actmap = Registry::allActions();
    for (auto & entry : actmap)
    {
      for (auto & act : entry.second)
        Moose::out << entry.first << "\taction\t" << act->_name << "\t" << act->_classname << "\t"
                   << act->_file << "\n";
    }

    _ready_to_exit = true;
  }
  else if (isParamValid("registry_hit"))
  {
    _perf_graph.disableLivePrint();

    Moose::out << "### START REGISTRY DATA ###\n";

    hit::Section root("");
    auto sec = new hit::Section("registry");
    root.addChild(sec);
    auto objsec = new hit::Section("objects");
    sec->addChild(objsec);

    auto & objmap = Registry::allObjects();
    for (auto & entry : objmap)
      for (auto & obj : entry.second)
      {
        auto ent = new hit::Section("entry");
        objsec->addChild(ent);
        ent->addChild(new hit::Field("label", hit::Field::Kind::String, entry.first));
        ent->addChild(new hit::Field("type", hit::Field::Kind::String, "object"));
        ent->addChild(new hit::Field("name", hit::Field::Kind::String, obj->name()));
        ent->addChild(new hit::Field("class", hit::Field::Kind::String, obj->_classname));
        ent->addChild(new hit::Field("file", hit::Field::Kind::String, obj->_file));
      }

    auto actsec = new hit::Section("actions");
    sec->addChild(actsec);
    auto & actmap = Registry::allActions();
    for (auto & entry : actmap)
      for (auto & act : entry.second)
      {
        auto ent = new hit::Section("entry");
        actsec->addChild(ent);
        ent->addChild(new hit::Field("label", hit::Field::Kind::String, entry.first));
        ent->addChild(new hit::Field("type", hit::Field::Kind::String, "action"));
        ent->addChild(new hit::Field("task", hit::Field::Kind::String, act->_name));
        ent->addChild(new hit::Field("class", hit::Field::Kind::String, act->_classname));
        ent->addChild(new hit::Field("file", hit::Field::Kind::String, act->_file));
      }

    Moose::out << root.render();

    Moose::out << "\n### END REGISTRY DATA ###\n";
    _ready_to_exit = true;
  }
  else if (isParamValid("definition"))
  {
    _perf_graph.disableLivePrint();

    JsonSyntaxTree tree("");
    _builder.buildJsonSyntaxTree(tree);
    SONDefinitionFormatter formatter;
    Moose::out << "%-START-SON-DEFINITION-%\n"
               << formatter.toString(tree.getRoot()) << "\n%-END-SON-DEFINITION-%\n";
    _ready_to_exit = true;
  }
  else if (isParamValid("yaml"))
  {
    _perf_graph.disableLivePrint();

    _builder.initSyntaxFormatter(Moose::Builder::YAML, true);

    // Get command line argument following --yaml on command line
    std::string yaml_following_arg = getParam<std::string>("yaml");

    // If the argument following --yaml is non-existent or begins with
    // a dash, call buildFullTree() with an empty string, otherwise
    // pass the argument following --yaml.
    if (yaml_following_arg.empty() || (yaml_following_arg.find('-') == 0))
      _builder.buildFullTree("");
    else
      _builder.buildFullTree(yaml_following_arg);

    _ready_to_exit = true;
  }
  else if (isParamValid("json"))
  {
    _perf_graph.disableLivePrint();

    // Get command line argument following --json on command line
    std::string json_following_arg = getParam<std::string>("json");

    // The argument following --json is a parameter search string,
    // which can be empty.
    std::string search;
    if (!json_following_arg.empty() && (json_following_arg.find('-') != 0))
      search = json_following_arg;

    JsonSyntaxTree tree(search);
    _builder.buildJsonSyntaxTree(tree);

    Moose::out << "**START JSON DATA**\n" << tree.getRoot().dump(2) << "\n**END JSON DATA**\n";
    _ready_to_exit = true;
  }
  else if (getParam<bool>("syntax"))
  {
    _perf_graph.disableLivePrint();

    std::multimap<std::string, Syntax::ActionInfo> syntax = _syntax.getAssociatedActions();
    Moose::out << "**START SYNTAX DATA**\n";
    for (const auto & it : syntax)
      Moose::out << it.first << "\n";
    Moose::out << "**END SYNTAX DATA**\n" << std::endl;
    _ready_to_exit = true;
  }
  else if (getParam<bool>("apptype"))
  {
    _perf_graph.disableLivePrint();

    Moose::out << "MooseApp Type: " << type() << std::endl;
    _ready_to_exit = true;
  }
  else if (getInputFileNames().size())
  {
    if (isParamValid("recover"))
    {
      // We need to set the flag manually here since the recover parameter is a string type (takes
      // an optional filename)
      _recover = true;

      // Get command line argument following --recover on command line
      std::string recover_following_arg = getParam<std::string>("recover");

      // If the argument following --recover is non-existent or begins with
      // a dash then we are going to eventually find the newest recovery file to use
      if (!(recover_following_arg.empty() || (recover_following_arg.find('-') == 0)))
        _restart_recover_base = recover_following_arg;
    }

    // In the event that we've parsed once before already in MooseMain, we
    // won't need to parse again
    if (!_parser->root())
      _parser->parse();

    _builder.build();

    if (isParamValid("mesh_only"))
    {
      _syntax.registerTaskName("mesh_only", true);
      _syntax.addDependency("mesh_only", "setup_mesh_complete");
      _syntax.addDependency("determine_system_type", "mesh_only");
      _action_warehouse.setFinalTask("mesh_only");
    }
    else if (isParamValid("split_mesh"))
    {
      _split_mesh = true;
      _syntax.registerTaskName("split_mesh", true);
      _syntax.addDependency("split_mesh", "setup_mesh_complete");
      _syntax.addDependency("determine_system_type", "split_mesh");
      _action_warehouse.setFinalTask("split_mesh");
    }
    _action_warehouse.build();

    // Setup the AppFileBase for use by the Outputs or other systems that need output file info
    {
      // Extract the CommonOutputAction
      const auto common_actions = _action_warehouse.getActions<CommonOutputAction>();
      mooseAssert(common_actions.size() <= 1, "Should not be more than one CommonOutputAction");
      const Action * common = common_actions.empty() ? nullptr : *common_actions.begin();

      // If file_base is set in CommonOutputAction through parsing input, obtain the file_base
      if (common && common->isParamValid("file_base"))
      {
        _output_file_base = common->getParam<std::string>("file_base");
        _file_base_set_by_user = true;
      }
      else if (isUltimateMaster())
      {
        // if this app is a master, we use the first input file name as the default file base
        std::string base = getLastInputFileName();
        size_t pos = base.find_last_of('.');
        _output_file_base = base.substr(0, pos);
        // Note: we did not append "_out" in the file base here because we do not want to
        //       have it in between the input file name and the object name for Output/*
        //       syntax.
      }
      // default file base for multiapps is set by MultiApp
    }
  }
  else if (isParamValid("input_file"))
  {
    mooseAssert(getInputFileNames().empty(), "Should be empty");
    mooseError("No input files specified. Add -i <inputfile> to your command line.");
  }
  else if (isParamValid("language_server"))
  {
    _perf_graph.disableLivePrint();

    // Reset output to the buffer what was cached before it was turned it off
    if (!Moose::out.rdbuf() && _output_buffer_cache)
      Moose::out.rdbuf(_output_buffer_cache);

    // Start a language server that communicates using an iostream connection
    MooseServer moose_server(*this);

    moose_server.run();

    _ready_to_exit = true;
  }

  else /* The catch-all case for bad options or missing options, etc. */
  {
    if (_check_input)
      mooseError("You specified --check-input, but did not provide an input file. Add -i "
                 "<inputfile> to your command line.");

    _command_line->printUsage();

    _ready_to_exit = true;
  }

  Moose::out << std::flush;
}

showInputs()

bool MooseApp::showInputs ( ) const

private

Prints a message showing the installable inputs for a given application (if getInstallableInputs has been overridden for an application).

Definition at line 1554 of file MooseApp.C.

Referenced by run().

{
  if (isParamValid("show_inputs"))
  {
    auto copy_syntax = _pars.getCommandLineSyntax("copy_inputs");
    std::vector<std::string> dirs;
    const auto installable_inputs = getInstallableInputs();

    if (installable_inputs == "")
    {
      Moose::out
          << "Show inputs has not been overriden in this application.\nContact the developers of "
             "this appication and request that they override \"MooseApp::getInstallableInputs\".\n";
    }
    else
    {
      mooseAssert(!copy_syntax.empty(), "copy_inputs sytnax should not be empty");

      MooseUtils::tokenize(installable_inputs, dirs, 1, " ");
      Moose::out << "The following directories are installable into a user-writeable directory:\n\n"
                 << installable_inputs << '\n'
                 << "\nTo install one or more directories of inputs, execute the binary with the \""
                 << copy_syntax[0] << "\" flag. e.g.:\n$ " << _command_line->getExecutableName()
                 << ' ' << copy_syntax[0] << ' ' << dirs[0] << '\n';
    }
    return true;
  }
  return false;
}

solutionInvalidity()

SolutionInvalidity& MooseApp::solutionInvalidity ( )

inline

Get the SolutionInvalidity for this app.

Definition at line 138 of file MooseApp.h.

Referenced by SolverSystem::checkInvalidSolution(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualInternal(), SolutionInvalidInterface::flagInvalidSolutionInternal(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), SolutionInvalidityReporter::SolutionInvalidityReporter(), and NonlinearSystem::solve().

{ return _solution_invalidity; }

syntax()

Syntax& MooseApp::syntax ( )

inline

Returns a writable reference to the syntax object.

Definition at line 209 of file MooseApp.h.

Referenced by dynamicAllRegistration(), and setupOptions().

{ return _syntax; }

testCheckpointHalfTransient()

bool MooseApp::testCheckpointHalfTransient ( ) const

inline

Whether or not this simulation should only run half its transient (useful for testing recovery)

Definition at line 510 of file MooseApp.h.

Referenced by AutoCheckpointAction::act(), TimeStepper::constrainStep(), Transient::execute(), TimeSequenceStepperBase::setupSequence(), and Transient::Transient().

{ return _test_checkpoint_half_transient; }

theWarehouse()

TheWarehouse& MooseApp::theWarehouse ( )

inline

Definition at line 102 of file MooseApp.h.

Referenced by MooseVariableDataFV< OutputType >::MooseVariableDataFV(), and FEProblemBase::theWarehouse().

{ return *_the_warehouse; }

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

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.

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

{ return _type; }

typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

Returns

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

Definition at line 27 of file MooseBase.C.

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

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

useEigenvalue()

bool& MooseApp::useEigenvalue ( )

inline

Returns a writable Boolean indicating whether this app will use an eigenvalue executioner.

Definition at line 391 of file MooseApp.h.

Referenced by CreateProblemDefaultAction::act().

{ return _use_eigen_value; }

useExecutor()

bool MooseApp::useExecutor ( ) const

inline

Definition at line 321 of file MooseApp.h.

{ return _use_executor; }

useNonlinear()

bool& MooseApp::useNonlinear ( )

inline

Returns a writable Boolean indicating whether this app will use a Nonlinear or Eigen System.

Definition at line 386 of file MooseApp.h.

Referenced by CreateProblemAction::act(), and CreateProblemDefaultAction::act().

{ return _use_nonlinear; }

validParams()

InputParameters MooseApp::validParams ( )

static

Definition at line 96 of file MooseApp.C.

{
  InputParameters params = emptyInputParameters();

  // Parameters that main also expects that we won't use (-i)
  Moose::addMainCommandLineParams(params);

  params.addCommandLineParam<bool>(
      "display_version", "-v --version", false, "Print application version");

  params.addCommandLineParam<std::string>(
      "mesh_only",
      "--mesh-only [mesh_file_name]",
      "Setup and Output the input mesh only (Default: \"<input_file_name>_in.e\")");

  params.addCommandLineParam<bool>("show_input",
                                   "--show-input",
                                   false,
                                   "Shows the parsed input file before running the simulation.");
  params.addCommandLineParam<bool>(
      "show_outputs", "--show-outputs", false, "Shows the output execution time information.");
  params.addCommandLineParam<bool>(
      "show_controls", "--show-controls", false, "Shows the Control logic available and executed.");

  params.addCommandLineParam<bool>(
      "no_color", "--no-color", false, "Disable coloring of all Console outputs.");
  params.addCommandLineParam<std::string>("color",
                                          "--color [auto,on,off]",
                                          "default-on",
                                          "Whether to use color in console output (default 'on').");

  params.addCommandLineParam<bool>("help", "-h --help", false, "Displays CLI usage statement.");
  params.addCommandLineParam<bool>(
      "minimal",
      "--minimal",
      false,
      "Ignore input file and build a minimal application with Transient executioner.");

  params.addCommandLineParam<bool>(
      "language_server",
      "--language-server",
      "Starts a process to communicate with development tools using the language server protocol");

  params.addCommandLineParam<std::string>(
      "definition", "--definition", "Shows a SON style input definition dump for input validation");
  params.addCommandLineParam<std::string>(
      "dump", "--dump [search_string]", "Shows a dump of available input file syntax.");
  params.addCommandLineParam<bool>(
      "registry", "--registry", "Lists all known objects and actions.");
  params.addCommandLineParam<bool>(
      "registry_hit", "--registry-hit", "Lists all known objects and actions in hit format.");
  params.addCommandLineParam<bool>(
      "use_executor", "--executor", false, "Use the new Executor system instead of Executioners");

  params.addCommandLineParam<bool>(
      "apptype", "--type", false, "Return the name of the application object.");
  params.addCommandLineParam<std::string>(
      "yaml", "--yaml", "Dumps input file syntax in YAML format.");
  params.addCommandLineParam<std::string>(
      "json", "--json", "Dumps input file syntax in JSON format.");
  params.addCommandLineParam<bool>(
      "syntax", "--syntax", false, "Dumps the associated Action syntax paths ONLY");
  params.addCommandLineParam<bool>(
      "show_docs", "--docs", false, "print url/path to the documentation website");
  params.addCommandLineParam<bool>("check_input",
                                   "--check-input",
                                   false,
                                   "Check the input file (i.e. requires -i <filename>) and quit.");
  params.addCommandLineParam<std::string>(
      "show_inputs",
      "--show-copyable-inputs",
      "Shows the directories able to be installed (copied) into a user-writable location");

  params.addCommandLineParam<std::string>("copy_inputs",
                                          "--copy-inputs <dir>",
                                          "Copies installed inputs (e.g. tests, examples, etc.) to "
                                          "an directory named  <appname>_<dir>.");
  params.addCommandLineParam<std::string>("run",
                                          "--run",
                                          "Runs the inputs in the current directory copied to a "
                                          "user-writable location by \"--copy-inputs\"");

  params.addCommandLineParam<bool>(
      "list_constructed_objects",
      "--list-constructed-objects",
      false,
      "List all moose object type names constructed by the master app factory.");

  params.addCommandLineParam<unsigned int>(
      "n_threads", "--n-threads=<n>", 1, "Runs the specified number of threads per process");

  params.addCommandLineParam<bool>("allow_unused",
                                   "-w --allow-unused",
                                   false,
                                   "Warn about unused input file options instead of erroring.");
  params.addCommandLineParam<bool>("error_unused",
                                   "-e --error-unused",
                                   false,
                                   "Error when encountering unused input file options");
  params.addCommandLineParam<bool>(
      "error_override",
      "-o --error-override",
      false,
      "Error when encountering overridden or parameters supplied multiple times");
  params.addCommandLineParam<bool>(
      "error_deprecated", "--error-deprecated", false, "Turn deprecated code messages into Errors");

  params.addCommandLineParam<bool>(
      "distributed_mesh",
      "--distributed-mesh",
      false,
      "The libMesh Mesh underlying MooseMesh should always be a DistributedMesh");

  params.addCommandLineParam<std::string>(
      "split_mesh",
      "--split-mesh [splits]",
      "comma-separated list of numbers of chunks to split the mesh into");

  params.addCommandLineParam<std::string>("split_file",
                                          "--split-file [filename]",
                                          "",
                                          "optional name of split mesh file(s) to write/read");

  params.addCommandLineParam<bool>(
      "use_split", "--use-split", false, "use split distributed mesh files");

  params.addCommandLineParam<unsigned int>(
      "refinements",
      "-r <n>",
      0,
      "Specify additional initial uniform mesh refinements for grid convergence studies");

  params.addCommandLineParam<std::string>("recover",
                                          "--recover [file_base]",
                                          "Continue the calculation.  If file_base is omitted then "
                                          "the most recent recovery file will be utilized");

  params.addCommandLineParam<bool>("test_checkpoint_half_transient",
                                   "--test-checkpoint-half-transient",
                                   false,
                                   "When true the simulation will only run half of "
                                   "its specified transient (ie half the "
                                   "timesteps) with checkpoints enabled. "
                                   "This is useful for testing recovery and restart "
                                   "and should only be used in the test harness.");

  params.addCommandLineParam<Real>("output_wall_time_interval",
                                   "--output-wall-time-interval [interval]",
                                   "The target wall time interval (in seconds) at "
                                   "which to write to output. "
                                   "USE FOR TEST SUITE PROBLEMS ONLY, FOR ALL OTHER USES "
                                   "SEE THE wall_time_interval IN DERIVED Output OBJECTS.");

  // No default on these two options, they must not both be valid
  params.addCommandLineParam<bool>(
      "trap_fpe",
      "--trap-fpe",
      "Enable Floating Point Exception handling in critical sections of "
      "code.  This is enabled automatically in DEBUG mode");
  params.addCommandLineParam<bool>("no_trap_fpe",
                                   "--no-trap-fpe",
                                   "Disable Floating Point Exception handling in critical "
                                   "sections of code when using DEBUG mode.");

  params.addCommandLineParam<bool>("error", "--error", false, "Turn all warnings into errors");

  params.addCommandLineParam<bool>(
      "timing",
      "-t --timing",
      false,
      "Enable all performance logging for timing purposes. This will disable all "
      "screen output of performance logs for all Console objects.");
  params.addCommandLineParam<bool>("no_timing",
                                   "--no-timing",
                                   false,
                                   "Disabled performance logging. Overrides -t or --timing "
                                   "if passed in conjunction with this flag");

  params.addCommandLineParam<bool>(
      "allow_test_objects", "--allow-test-objects", false, "Register test objects and syntax.");

  // Options ignored by MOOSE but picked up by libMesh, these are here so that they are displayed in
  // the application help
  params.addCommandLineParam<bool>(
      "keep_cout",
      "--keep-cout",
      false,
      "Keep standard output from all processors when running in parallel");
  params.addCommandLineParam<bool>(
      "redirect_stdout",
      "--redirect-stdout",
      false,
      "Keep standard output from all processors when running in parallel");

  params.addCommandLineParam<std::string>(
      "timpi_sync",
      "--timpi-sync <sync type>",
      "nbx",
      "Changes the sync type used in spare parallel communitations within the TIMPI library "
      "(advanced option).");

  // Options for debugging
  params.addCommandLineParam<std::string>("start_in_debugger",
                                          "--start-in-debugger <debugger>",
                                          "Start the application and attach a debugger.  This will "
                                          "launch xterm windows using the command you specify for "
                                          "'debugger'");

  params.addCommandLineParam<unsigned int>("stop_for_debugger",
                                           "--stop-for-debugger [seconds]",
                                           30,
                                           "Pauses the application during startup for the "
                                           "specified time to allow for connection of debuggers.");

  params.addCommandLineParam<bool>("perf_graph_live_all",
                                   "--perf-graph-live-all",
                                   false,
                                   "Forces printing of ALL progress messages.");

  params.addCommandLineParam<bool>("disable_perf_graph_live",
                                   "--disable-perf-graph-live",
                                   false,
                                   "Disables PerfGraph Live Printing.");

  params.addParam<bool>(
      "automatic_automatic_scaling", false, "Whether to turn on automatic scaling by default.");

#ifdef HAVE_GPERFTOOLS
  params.addCommandLineParam<std::string>(
      "gperf_profiler_on",
      "--gperf-profiler-on [ranks]",
      "To generate profiling report only on comma-separated list of MPI ranks.");
#endif

  params.addPrivateParam<std::string>("_app_name"); // the name passed to AppFactory::create
  params.addPrivateParam<std::string>("_type");
  params.addPrivateParam<int>("_argc");
  params.addPrivateParam<char **>("_argv");
  params.addPrivateParam<std::shared_ptr<CommandLine>>("_command_line");
  params.addPrivateParam<std::shared_ptr<Parallel::Communicator>>("_comm");
  params.addPrivateParam<unsigned int>("_multiapp_level");
  params.addPrivateParam<unsigned int>("_multiapp_number");
  params.addPrivateParam<const MooseMesh *>("_master_mesh");
  params.addPrivateParam<const MooseMesh *>("_master_displaced_mesh");
  params.addPrivateParam<std::unique_ptr<Backup> *>("_initial_backup", nullptr);
  params.addPrivateParam<std::shared_ptr<Parser>>("_parser");

  params.addParam<bool>(
      "use_legacy_material_output",
      true,
      "Set false to allow material properties to be output on INITIAL, not just TIMESTEP_END.");
  params.addParam<bool>(
      "use_legacy_initial_residual_evaluation_bahavior",
      true,
      "The legacy behavior performs an often times redundant residual evaluation before the "
      "solution modifying objects are executed prior to the initial (0th nonlinear iteration) "
      "residual evaluation. The new behavior skips that redundant residual evaluation unless the "
      "parameter Executioner/use_pre_SMO_residual is set to true.");

  params.addParam<bool>(
      MeshGeneratorSystem::allow_data_driven_param,
      false,
      "Set true to enable data-driven mesh generation, which is an experimental feature");

  MooseApp::addAppParam(params);

  return params;
}

writeRestartableMetaData() [1/2]

std::vector< std::filesystem::path > MooseApp::writeRestartableMetaData	(	const RestartableDataMapName &	name,
		const std::filesystem::path &	folder_base
	)

Writes the restartable meta data for name with a folder base of folder_base.

Returns

The files that were written

Definition at line 1910 of file MooseApp.C.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), Checkpoint::output(), and writeRestartableMetaData().

{
  if (processor_id() != 0)
    mooseError("MooseApp::writeRestartableMetaData(): Should only run on processor 0");

  const auto & map_name = getRestartableDataMapName(name);
  const auto meta_data_folder_base = metaDataFolderBase(folder_base, map_name);

  RestartableDataWriter writer(*this, getRestartableDataMap(name));
  return writer.write(meta_data_folder_base);
}

writeRestartableMetaData() [2/2]

std::vector< std::filesystem::path > MooseApp::writeRestartableMetaData

(

const std::filesystem::path &

folder_base

)

Writes all available restartable meta data with a file base of file_base.

Returns

The files that were written

Definition at line 1924 of file MooseApp.C.

{
  std::vector<std::filesystem::path> paths;

  if (processor_id() == 0)
    for (const auto & name_map_pair : _restartable_meta_data)
    {
      const auto map_paths = writeRestartableMetaData(name_map_pair.first, folder_base);
      paths.insert(paths.end(), map_paths.begin(), map_paths.end());
    }

  return paths;
}

Friends And Related Function Documentation

FEProblemBase

friend class FEProblemBase

friend

Definition at line 1458 of file MooseApp.h.

Restartable

friend class Restartable

friend

Definition at line 1459 of file MooseApp.h.

SubProblem

friend class SubProblem

friend

Definition at line 1460 of file MooseApp.h.

Member Data Documentation

_action_factory

ActionFactory MooseApp::_action_factory

protected

The Factory responsible for building Actions.

Definition at line 1131 of file MooseApp.h.

Referenced by createMinimalApp(), getActionFactory(), and MooseApp().

_action_warehouse

ActionWarehouse MooseApp::_action_warehouse

protected

Where built actions are stored.

Definition at line 1134 of file MooseApp.h.

Referenced by actionWarehouse(), attachRelationshipManagers(), constructingMeshGenerators(), createMinimalApp(), getCheckpointDirectories(), getCurrentActionHitNode(), getRelationshipManagerInfo(), removeRelationshipManager(), runInputFile(), setupOptions(), and ~MooseApp().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), ElementIDOutputAction::act(), AutoCheckpointAction::act(), DeclareLateReportersAction::act(), CheckIntegrityAction::act(), ExecuteMeshGenerators::act(), AddExecutorAction::act(), ReadExecutorParamsAction::act(), SetupMeshCompleteAction::act(), AddMeshGeneratorAction::act(), CopyNodalVarsAction::act(), CreateExecutionerAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), SetupDebugAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), ComposeTimeStepperAction::act(), AddRelationshipManager::act(), SetAdaptivityOptionsAction::act(), CouplingFunctorCheckAction::act(), DisplayGhostingAction::act(), CreateAddedMeshGenerators::act(), ResolveOptionalMaterialPropertiesAction::act(), SetupRecoverFileBaseAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addMultiApp(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FVFluxKernel::adjustRMGhostLayers(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), MooseBase::callMooseError(), CheckOutputAction::checkConsoleOutput(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), CheckOutputAction::checkMaterialOutput(), FEProblemBase::checkNonlinearConvergence(), CheckOutputAction::checkPerfLogOutput(), CheckOutputAction::checkVariableOutput(), SingleRankPartitioner::clone(), RandomPartitioner::clone(), BlockWeightedPartitioner::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostEverything::clone(), GhostLowerDElems::clone(), LibmeshPartitioner::clone(), PetscExternalPartitioner::clone(), HierarchicalGridPartitioner::clone(), GridPartitioner::clone(), ElementSideNeighborLayers::clone(), ElementPointNeighborLayers::clone(), RedistributeProperties::clone(), ProxyRelationshipManager::clone(), OversampleOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), MultiApp::createApp(), MultiApp::createApps(), MultiApp::createLocalApp(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::dumpVariableHelper(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), NonlinearEigen::execute(), InversePowerMethod::execute(), PseudoTimestep::execute(), IterationInfo::execute(), PIDTransientControl::execute(), Transient::execute(), Steady::execute(), Eigenvalue::execute(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), SideSetsFromNormalsGenerator::generate(), MeshGenerator::generateInternal(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), MooseBase::getMooseApp(), NumRelationshipManagers::getValue(), NumFixedPointIterations::getValue(), GhostingUserObject::GhostingUserObject(), InversePowerMethod::init(), NonlinearEigen::init(), Transient::init(), MooseMesh::init(), FEProblemBase::init(), TimePeriod::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), EigenProblem::initPetscOutputAndSomeSolverSettings(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MeshGenerator::MeshGenerator(), MooseObject::MooseObject(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), PerfGraphOutput::output(), Tecplot::output(), Exodus::output(), Nemesis::output(), Checkpoint::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), JSONOutput::outputSystemInformation(), Console::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), Transient::preExecute(), PhysicsBase::prepareCopyNodalVariables(), Eigenvalue::prepareSolverOptions(), FEProblemBase::projectSolution(), TiledMesh::safeClone(), FileMesh::safeClone(), ImageMesh::safeClone(), SpiralAnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), RinglebMesh::safeClone(), AnnularMesh::safeClone(), GeneratedMesh::safeClone(), MeshGeneratorMesh::safeClone(), StitchedMesh::safeClone(), PatternedMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), FEProblemBase::timestepSetup(), Transient::Transient(), FEProblemBase::updateMortarMesh(), Console::write(), and FEProblemBase::~FEProblemBase().

_attached_relationship_managers

std::map<Moose::RelationshipManagerType, std::set<const RelationshipManager *> > MooseApp::_attached_relationship_managers

protected

The relationship managers that have been attached (type -> RMs)

Definition at line 1252 of file MooseApp.h.

Referenced by attachRelationshipManagers().

_automatic_automatic_scaling

const bool MooseApp::_automatic_automatic_scaling

private

Whether to turn on automatic scaling by default.

Definition at line 1434 of file MooseApp.h.

Referenced by defaultAutomaticScaling().

_builder

Moose::Builder MooseApp::_builder

protected

Builder for building app related parser tree.

Definition at line 1143 of file MooseApp.h.

Referenced by builder(), errorCheck(), getFileName(), and setupOptions().

_check_input

bool MooseApp::_check_input

protected

true if we want to just check the input file

Definition at line 1245 of file MooseApp.h.

Referenced by checkInput(), MooseApp(), run(), and setupOptions().

_comm

const std::shared_ptr<Parallel::Communicator> MooseApp::_comm

protected

The MPI communicator this App is going to use.

Definition at line 1097 of file MooseApp.h.

Referenced by errorCheck(), getCommunicator(), MooseApp(), and processor_id().

_command_line

std::shared_ptr<CommandLine> MooseApp::_command_line

protected

Command line object.

Definition at line 1121 of file MooseApp.h.

Referenced by commandLine(), copyInputs(), executeExecutioner(), MooseApp(), runInputs(), setupOptions(), and showInputs().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

_cpu_profiling

bool MooseApp::_cpu_profiling = false

private

CPU profiling.

Definition at line 1437 of file MooseApp.h.

Referenced by MooseApp(), and ~MooseApp().

_distributed_mesh_on_command_line

bool MooseApp::_distributed_mesh_on_command_line

protected

This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh.

Definition at line 1218 of file MooseApp.h.

Referenced by getDistributedMeshOnCommandLine(), and setupOptions().

_enable_unused_check

enum MooseApp::UNUSED_CHECK MooseApp::_enable_unused_check

protected

Referenced by disableCheckUnusedFlag(), errorCheck(), and setCheckUnusedFlag().

_error_overridden

bool MooseApp::_error_overridden

protected

Indicates whether warnings or errors are displayed when overridden parameters are detected.

Definition at line 1208 of file MooseApp.h.

Referenced by setErrorOverridden().

_ex_reader

std::shared_ptr<ExodusII_IO> MooseApp::_ex_reader

protected

The Exodus reader when _initial_from_file is set to true.

Definition at line 1215 of file MooseApp.h.

Referenced by getExReaderForRestart(), and setExReaderForRestart().

_execute_flags

const ExecFlagEnum MooseApp::_execute_flags

private

Execution flags for this App.

Note: These are copied on purpose instead of maintaining a reference to the ExecFlagRegistry registry. In the Multiapp case, the registry may be augmented, changing the flags "known" to the application in the middle of executing the setup. This causes issues with the application having to process flags that aren't specifically registered.

Definition at line 1428 of file MooseApp.h.

Referenced by getExecuteOnEnum().

_executioner

std::shared_ptr<Executioner> MooseApp::_executioner

protected

Pointer to the executioner of this run (typically build by actions)

Definition at line 1164 of file MooseApp.h.

Referenced by attachRelationshipManagers(), executeExecutioner(), feProblem(), getExecutioner(), removeRelationshipManager(), setExecutioner(), setOutputPosition(), and ~MooseApp().

_executor

std::shared_ptr<Executor> MooseApp::_executor

protected

Pointer to the Executor of this run.

Definition at line 1167 of file MooseApp.h.

Referenced by attachRelationshipManagers(), createExecutors(), executeExecutioner(), feProblem(), getExecutioner(), getExecutor(), and setExecutor().

_executor_params

std::unordered_map<std::string, std::pair<std::string, std::unique_ptr<InputParameters> > > MooseApp::_executor_params

protected

Used in building the Executors Maps the name of the Executor block to the <type, params>

Definition at line 1175 of file MooseApp.h.

Referenced by addExecutorParams(), createExecutors(), and recursivelyCreateExecutors().

_executors

std::map<std::string, std::shared_ptr<Executor> > MooseApp::_executors

protected

Pointers to all of the Executors for this run.

Definition at line 1170 of file MooseApp.h.

Referenced by addExecutor(), createExecutors(), getExecutor(), and recursivelyCreateExecutors().

_factory

Factory MooseApp::_factory

protected

Definition at line 1205 of file MooseApp.h.

Referenced by addExecutor(), createExecutors(), getFactory(), MooseApp(), removeRelationshipManager(), and runInputFile().

_file_base_set_by_user

bool MooseApp::_file_base_set_by_user

protected

Whether or not file base is set through input or setOutputFileBase by MultiApp.

Definition at line 1103 of file MooseApp.h.

Referenced by getCheckpointDirectories(), getOutputFileBase(), setOutputFileBase(), and setupOptions().

_fixed_point_config

FixedPointConfig MooseApp::_fixed_point_config

protected

Multiapp-related fixed point algorithm configuration details primarily intended to be passed to and used by the executioner/executor system.

Definition at line 1179 of file MooseApp.h.

Referenced by fixedPointConfig().

_global_time_offset

Real MooseApp::_global_time_offset

protected

Offset of the local App time to the "global" problem time.

Definition at line 1118 of file MooseApp.h.

Referenced by getGlobalTimeOffset(), and setGlobalTimeOffset().

_heap_profiling

bool MooseApp::_heap_profiling = false

private

Memory profiling.

Definition at line 1440 of file MooseApp.h.

Referenced by MooseApp(), and ~MooseApp().

_initial_backup

std::unique_ptr<Backup>* const MooseApp::_initial_backup

private

The backup for use in initial setup; this will get set from the _initial_backup input parameter that typically gets set from a MultiApp that has a backup This is a pointer to a pointer because at the time of construction of the app, the backup will not be filled yet.

Definition at line 1455 of file MooseApp.h.

Referenced by hasInitialBackup(), and restoreFromInitialBackup().

_initial_from_file

bool MooseApp::_initial_from_file

protected

This variable indicates when a request has been made to restart from an Exodus file.

Definition at line 1212 of file MooseApp.h.

Referenced by getExodusFileRestart(), and setExodusFileRestart().

_input_parameter_warehouse

std::unique_ptr<InputParameterWarehouse> MooseApp::_input_parameter_warehouse

protected

Input parameter storage structure; unique_ptr so we can control its destruction order.

Definition at line 1128 of file MooseApp.h.

Referenced by getInputParameterWarehouse(), and ~MooseApp().

_interface_registry

std::map<std::type_index, std::unique_ptr<InterfaceRegistryObjectsBase> > MooseApp::_interface_registry

private

Registration for interface objects.

Definition at line 1449 of file MooseApp.h.

Referenced by getInterfaceObjects(), and registerInterfaceObject().

_lib_handles

std::unordered_map<std::string, DynamicLibraryInfo> MooseApp::_lib_handles

protected

The library archive (name only), registration method and the handle to the method.

Definition at line 1268 of file MooseApp.h.

Referenced by getLoadedLibraryPaths(), loadLibraryAndDependencies(), and ~MooseApp().

_master_displaced_mesh

const MooseMesh* const MooseApp::_master_displaced_mesh

private

The displaced mesh from master app.

Definition at line 1414 of file MooseApp.h.

Referenced by masterDisplacedMesh(), and MooseApp().

_master_mesh

const MooseMesh* const MooseApp::_master_mesh

private

The mesh from master app.

Definition at line 1411 of file MooseApp.h.

Referenced by masterMesh(), and MooseApp().

_mesh_generator_system

MeshGeneratorSystem MooseApp::_mesh_generator_system

private

The system that manages the MeshGenerators.

Definition at line 1417 of file MooseApp.h.

Referenced by addMeshGenerator(), appendMeshGenerator(), constructingMeshGenerators(), getMeshGenerator(), getMeshGeneratorMesh(), getMeshGeneratorNames(), getMeshGeneratorSystem(), and hasMeshGenerator().

_multiapp_level

unsigned int MooseApp::_multiapp_level

private

Level of multiapp, the master is level 0. This used by the Console to indent output.

Definition at line 1405 of file MooseApp.h.

Referenced by getOutputFileBase(), isUltimateMaster(), MooseApp(), and multiAppLevel().

_multiapp_number

unsigned int MooseApp::_multiapp_number

private

Numbering in all the sub-apps on the same level.

Definition at line 1408 of file MooseApp.h.

Referenced by multiAppNumber().

_name

const std::string MooseApp::_name

protected

The name of this object.

Definition at line 1088 of file MooseApp.h.

Referenced by setupOptions().

_null_executor

std::shared_ptr<NullExecutor> MooseApp::_null_executor

protected

Used to return an executor that does nothing.

Definition at line 1186 of file MooseApp.h.

Referenced by createExecutors(), getExecutor(), and getNullExecutor().

_output_buffer_cache

std::streambuf* MooseApp::_output_buffer_cache

private

Cache output buffer so the language server can turn it off then back on.

Definition at line 1431 of file MooseApp.h.

Referenced by MooseApp(), and setupOptions().

_output_file_base

std::string MooseApp::_output_file_base

protected

The output file basename.

Definition at line 1100 of file MooseApp.h.

Referenced by getOutputFileBase(), setOutputFileBase(), and setupOptions().

_output_file_numbers

std::map<std::string, unsigned int> MooseApp::_output_file_numbers

protected

Map of outputer name and file number (used by MultiApps to propagate file numbers down through the multiapps)

Definition at line 1242 of file MooseApp.h.

Referenced by getOutputFileNumbers(), and setOutputFileNumbers().

_output_position

Point MooseApp::_output_position

protected

The output position.

Definition at line 1109 of file MooseApp.h.

Referenced by getOutputPosition(), and setOutputPosition().

_output_position_set

bool MooseApp::_output_position_set

protected

Whether or not an output position has been set for this app.

Definition at line 1106 of file MooseApp.h.

Referenced by hasOutputPosition(), and setOutputPosition().

_output_warehouse

OutputWarehouse MooseApp::_output_warehouse

protected

OutputWarehouse object for this App.

Definition at line 1137 of file MooseApp.h.

Referenced by getOutputWarehouse(), setOutputFileBase(), and setOutputPosition().

_pars

InputParameters MooseApp::_pars

protected

Parameters of this object.

Definition at line 1091 of file MooseApp.h.

Referenced by copyInputs(), getParam(), getRenamedParam(), isParamSetByUser(), isParamValid(), parameters(), setupOptions(), and showInputs().

_parser

const std::shared_ptr<Parser> MooseApp::_parser

protected

Parser for parsing the input file.

Definition at line 1140 of file MooseApp.h.

Referenced by getInputFileNames(), getLastInputFileName(), parser(), and setupOptions().

_perf_graph

PerfGraph& MooseApp::_perf_graph

protected

The PerfGraph object for this application (recoverable)

Definition at line 1155 of file MooseApp.h.

Referenced by perfGraph(), and setupOptions().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_rank_map

const RankMap MooseApp::_rank_map

protected

The RankMap is a useful object for determining how the processes are laid out on the physical hardware.

Definition at line 1161 of file MooseApp.h.

Referenced by rankMap().

_rd_reader

RestartableDataReader MooseApp::_rd_reader

private

Definition at line 1419 of file MooseApp.h.

Referenced by finalizeRestore(), and restore().

_ready_to_exit

bool MooseApp::_ready_to_exit

protected

Definition at line 1209 of file MooseApp.h.

Referenced by executeExecutioner(), run(), runInputFile(), and setupOptions().

_recover

bool MooseApp::_recover

protected

Whether or not this is a recovery run.

Definition at line 1221 of file MooseApp.h.

Referenced by isRecovering(), setRecover(), and setupOptions().

_recoverable_data_names

DataNames MooseApp::_recoverable_data_names

protected

Data names that will only be read from the restart file during RECOVERY.

e.g. these names are excluded during restart.

Definition at line 1152 of file MooseApp.h.

Referenced by getRecoverableData(), and registerRestartableNameWithFilter().

_relationship_managers

std::set<std::shared_ptr<RelationshipManager> > MooseApp::_relationship_managers

protected

The relationship managers that have been added.

Definition at line 1248 of file MooseApp.h.

Referenced by addRelationshipManager(), attachRelationshipManagers(), getRelationshipManagerInfo(), hasRelationshipManager(), relationshipManagers(), and removeRelationshipManager().

_restart

bool MooseApp::_restart

protected

Whether or not this is a restart run.

Definition at line 1224 of file MooseApp.h.

Referenced by isRestarting(), and setRestart().

_restart_recover_base

std::string MooseApp::_restart_recover_base

protected

The base name to restart/recover from. If blank then we will find the newest checkpoint file.

Definition at line 1236 of file MooseApp.h.

Referenced by getRecoverFileBase(), getRestartRecoverFileBase(), hasRecoverFileBase(), hasRestartRecoverFileBase(), setRestartRecoverFileBase(), and setupOptions().

_restartable_data

std::vector<RestartableDataMap> MooseApp::_restartable_data

protected

Where the restartable data is held (indexed on tid)

Definition at line 1146 of file MooseApp.h.

Referenced by backup(), getRestartableData(), registerRestartableData(), and ~MooseApp().

_restartable_meta_data

std::unordered_map<RestartableDataMapName, std::pair<RestartableDataMap, std::string> > MooseApp::_restartable_meta_data

private

General storage for custom RestartableData that can be added to from outside applications.

Definition at line 1392 of file MooseApp.h.

Referenced by checkMetaDataIntegrity(), getRestartableDataMap(), getRestartableDataMapBegin(), getRestartableDataMapEnd(), getRestartableDataMapName(), hasRestartableDataMap(), hasRestartableMetaData(), loadRestartableMetaData(), registerRestartableData(), registerRestartableDataMapName(), and writeRestartableMetaData().

_solution_invalidity

SolutionInvalidity& MooseApp::_solution_invalidity

protected

The SolutionInvalidity object for this application.

Definition at line 1158 of file MooseApp.h.

Referenced by solutionInvalidity().

_split_mesh

bool MooseApp::_split_mesh

protected

Whether or not we are performing a split mesh operation (–split-mesh)

Definition at line 1227 of file MooseApp.h.

Referenced by isSplitMesh(), and setupOptions().

_start_time

Real MooseApp::_start_time

protected

The time at which to start the simulation.

Definition at line 1115 of file MooseApp.h.

Referenced by getStartTime(), and setStartTime().

_start_time_set

bool MooseApp::_start_time_set

protected

Whether or not an start time has been set.

Definition at line 1112 of file MooseApp.h.

Referenced by hasStartTime(), and setStartTime().

_syntax

Syntax MooseApp::_syntax

protected

Syntax of the input file.

Definition at line 1124 of file MooseApp.h.

Referenced by MooseApp(), setupOptions(), and syntax().

_sys_info

std::unique_ptr<SystemInfo> MooseApp::_sys_info

protected

System Information.

Definition at line 1195 of file MooseApp.h.

Referenced by getSystemInfo(), and MooseApp().

_template_to_clones

std::map<const RelationshipManager *, std::map<const MeshBase *, std::unique_ptr<RelationshipManager> > > MooseApp::_template_to_clones

private

Map from a template relationship manager to a map in which the key-value pairs represent the MeshBase object and the clone of the template relationship manager, e.g.

the top-level map key

Definition at line 1446 of file MooseApp.h.

Referenced by createRMFromTemplateAndInit(), getRMClone(), and hasRMClone().

_test_checkpoint_half_transient

bool MooseApp::_test_checkpoint_half_transient

protected

Whether or not this simulation should only run half its transient (useful for testing recovery)

Definition at line 1239 of file MooseApp.h.

Referenced by setupOptions(), and testCheckpointHalfTransient().

_the_warehouse

std::unique_ptr<TheWarehouse> MooseApp::_the_warehouse

private

The combined warehouse for storing any MooseObject based object.

Definition at line 1402 of file MooseApp.h.

Referenced by MooseApp(), theWarehouse(), and ~MooseApp().

_trap_fpe

bool MooseApp::_trap_fpe

protected

Whether or not FPE trapping should be turned on.

Definition at line 1233 of file MooseApp.h.

Referenced by getFPTrapFlag(), and setupOptions().

_type

const std::string MooseApp::_type

protected

The string representation of the type of this object as registered (see registerApp(AppName))

Definition at line 1094 of file MooseApp.h.

Referenced by MooseApp().

_undisp_to_disp_rms

std::unordered_map<RelationshipManager *, std::shared_ptr<GhostingFunctor> > MooseApp::_undisp_to_disp_rms

protected

A map from undisplaced relationship managers to their displaced clone (stored as the base GhostingFunctor).

Anytime we clone in attachRelationshipManagers we create a map entry from the cloned undisplaced relationship manager to its displaced clone counterpart. We leverage this map when removing relationship managers/ghosting functors

Definition at line 1258 of file MooseApp.h.

_use_eigen_value

bool MooseApp::_use_eigen_value

protected

Boolean to indicate whether to use an eigenvalue executioner.

Definition at line 1192 of file MooseApp.h.

Referenced by useEigenvalue().

_use_executor

const bool MooseApp::_use_executor

protected

Indicates whether we are operating in the new/experimental executor mode instead of using the legacy executioner system.

Definition at line 1183 of file MooseApp.h.

Referenced by executeExecutioner(), and useExecutor().

_use_nonlinear

bool MooseApp::_use_nonlinear

protected

Boolean to indicate whether to use a Nonlinear or EigenSystem (inspected by actions)

Definition at line 1189 of file MooseApp.h.

Referenced by useNonlinear().

_use_split

const bool MooseApp::_use_split

protected

Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)

Definition at line 1230 of file MooseApp.h.

MESH_META_DATA

const RestartableDataMapName MooseApp::MESH_META_DATA = "MeshMetaData"

static

Definition at line 95 of file MooseApp.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), SetupDebugAction::act(), FileMesh::buildMesh(), MeshGenerator::declareMeshProperty(), FileMeshGenerator::generate(), MeshMetaDataInterface::getMeshPropertyInternal(), MeshMetaDataInterface::hasMeshProperty(), MooseApp(), MeshGenerator::setMeshPropertyHelper(), and MeshMetaDataReporter::validParams().

MESH_META_DATA_SUFFIX

const RestartableDataMapName MooseApp::MESH_META_DATA_SUFFIX = "mesh"

static

Definition at line 96 of file MooseApp.h.

Referenced by MooseApp().

---

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

• include/base/MooseApp.h
• src/base/MooseApp.C