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
torch::DeviceType	getLibtorchDevice () const
	Get the device torch is supposed to be running on. More...

virtual	~MooseApp ()

TheWarehouse &	theWarehouse ()

virtual std::string	getPrintableName () const
	Get printable name of the application. More...

virtual std::string	appBinaryName () const

int	exitCode () const
	Get the shell exit code for the application. More...

void	setExitCode (const int exit_code)
	Sets the exit code that the application will exit with. More...

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

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< libMesh::ExodusII_IO > &&exreader)
	Set the Exodus reader to restart variables from an Exodus mesh file. More...

libMesh::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 OutputWarehouse &	getOutputWarehouse () const

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

ChainControlDataSystem &	getChainControlDataSystem ()
	Gets the system that manages the ChainControls. 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< libMesh::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...


SolutionInvalidity &	solutionInvalidity ()
	Get the SolutionInvalidity for this app. More...

const SolutionInvalidity &	solutionInvalidity () const


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)

static void	addInputParam (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 libMesh::Parameters &params)
	Helper method for dynamic loading of objects. More...

void	loadLibraryAndDependencies (const std::string &library_filename, const libMesh::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
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< libMesh::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...

std::string	_early_exit_param
	Indicates if simulation is ready to exit, and keeps track of which param caused it to exit. More...

bool	_ready_to_exit

int	_exit_code
	The exit code. More...

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

std::shared_ptr< libMesh::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< libMesh::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...

const std::string	_name
	The name of this class. 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...

torch::DeviceType	determineLibtorchDeviceType (const MooseEnum &device) const
	Function to determine the device which should be used by libtorch on this application. 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 libMesh::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 ()
	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 ()
	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...

ChainControlDataSystem	_chain_control_system
	The system that manages the ChainControls. 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...

const torch::DeviceType	_libtorch_device
	The libtorch device this app is using. 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 82 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 1445 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 1243 of file MooseApp.h.

   {
     OFF,
     WARN_UNUSED,
     ERROR_UNUSED
   } _enable_unused_check;

Constructor & Destructor Documentation

◆ ~MooseApp()

virtual MooseApp::~MooseApp ( )

virtual

◆ MooseApp()

MooseApp::MooseApp ( InputParameters parameters )

protected

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

Definition at line 404 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),
     _early_exit_param(""),
     _ready_to_exit(false),
     _exit_code(0),
     _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),
     _chain_control_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"))
 #ifdef LIBTORCH_ENABLED
     ,
     _libtorch_device(determineLibtorchDeviceType(getParam<MooseEnum>("libtorch_device")))
 #endif
 {
   // 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 (isParamSetByUser("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") && getParam<bool>("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);
 
   _perf_graph.enableLivePrint();
 
   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 && isParamSetByUser("recover"))
     mooseError("Cannot run --check-input with --recover. Recover files might not exist");
 
   if (isParamSetByUser("start_in_debugger") && isUltimateMaster())
   {
     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 (isParamSetByUser("stop_for_debugger") && isUltimateMaster())
   {
     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;
 }
 
 MooseApp::~MooseApp()
 {
 #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
 }

Member Function Documentation

◆ actionWarehouse() [1/2]

ActionWarehouse& MooseApp::actionWarehouse ( )

inline

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

Definition at line 223 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::DumpObjectsProblem(), 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().

223 { return _action_warehouse; }

MooseApp::_action_warehouse

ActionWarehouse _action_warehouse

Where built actions are stored.

Definition: MooseApp.h:1179

◆ actionWarehouse() [2/2]

const ActionWarehouse& MooseApp::actionWarehouse ( ) const

inline

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

Definition at line 227 of file MooseApp.h.

227 { return _action_warehouse; }

MooseApp::_action_warehouse

ActionWarehouse _action_warehouse

Where built actions are stored.

Definition: MooseApp.h:1179

◆ addAppParam()

void MooseApp::addAppParam ( InputParameters & params )

static

Definition at line 90 of file MooseApp.C.

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

 {
   params.addCommandLineParam<std::string>(
       "app_to_run", "--app <type>", "Specify the application type to run (case-sensitive)");
 }

◆ addExecutor()

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

Definition at line 1402 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 1414 of file MooseApp.C.

Referenced by ReadExecutorParamsAction::act().

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

◆ addInputParam()

void MooseApp::addInputParam ( InputParameters & params )

static

Definition at line 97 of file MooseApp.C.

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

 {
   params.addCommandLineParam<std::vector<std::string>>(
       "input_file", "-i <input file(s)>", "Specify input file(s); multiple files are merged");
 }

◆ 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 868 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 2430 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 123 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 919 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 1860 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 2640 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.

◆ 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 1284 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 1295 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 232 of file MooseApp.h.

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

232 { return _builder; }

MooseApp::_builder

Moose::Builder _builder

Builder for building app related parser tree.

Definition: MooseApp.h:1188

◆ 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 942 of file MooseApp.h.

942 { return _check_input; }

MooseApp::_check_input

bool _check_input

true if we want to just check the input file

Definition: MooseApp.h:1294

◆ checkMetaDataIntegrity()

void MooseApp::checkMetaDataIntegrity ( ) const

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

Definition at line 2831 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 2478 of file MooseApp.C.

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

 {
   static const std::string suffix = "-mesh.cpa.gz";
   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 441 of file MooseApp.h.

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

441 { return _command_line; }

MooseApp::_command_line

std::shared_ptr< CommandLine > _command_line

Command line object.

Definition: MooseApp.h:1166

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

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 1663 of file MooseApp.C.

Referenced by run().

 {
   if (isParamSetByUser("copy_inputs"))
   {
     if (comm().size() > 1)
       mooseError("The --copy-inputs option should not be ran in parallel");
 
     // 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.getCommandLineMetadata("show_inputs").switches[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");
 
     mooseAssert(comm().size() == 1, "Should be run in serial");
     const auto return_value = system(cmd.c_str());
     if (!WIFEXITED(return_value))
       mooseError("Process exited unexpectedly");
     setExitCode(WEXITSTATUS(return_value));
     if (exitCode() == 0)
       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 1481 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 2330 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 2899 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 2917 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 libMesh::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 2574 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 1045 of file MooseApp.h.

1045 { return _automatic_automatic_scaling; }

MooseApp::_automatic_automatic_scaling

const bool _automatic_automatic_scaling

Whether to turn on automatic scaling by default.

Definition: MooseApp.h:1487

◆ determineLibtorchDeviceType()

torch::DeviceType MooseApp::determineLibtorchDeviceType ( const MooseEnum & device ) const

private

Function to determine the device which should be used by libtorch on this application.

We use this function to decide what is available on different builds.

Parameters

device Enum to describe if a cpu or a gpu should be used.

Definition at line 2938 of file MooseApp.C.

 {
   if (device_enum == "cuda")
   {
 #ifdef __linux__
     if (!torch::cuda::is_available())
       mooseError("--libtorch-device=cuda: CUDA is not available");
     return torch::kCUDA;
 #else
     mooseError("--libtorch-device=cuda: CUDA is not supported on your platform");
 #endif
   }
   else if (device_enum == "mps")
   {
 #ifdef __APPLE__
     if (!torch::mps::is_available())
       mooseError("--libtorch-device=mps: MPS is not available");
     return torch::kMPS;
 #else
     mooseError("--libtorch-device=mps: MPS is not supported on your platform");
 #endif
   }
 
   mooseAssert(device_enum == "cpu", "Should be cpu");
   return torch::kCPU;
 }

◆ disableCheckUnusedFlag()

void MooseApp::disableCheckUnusedFlag ( )

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

Definition at line 1390 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 2077 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 2020 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 libMesh::Parameters & params )

protected

Helper method for dynamic loading of objects.

Definition at line 2106 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 1171 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);
 
   // Return early for mesh only mode, since we want error checking to run even though
   // an executor is not created for this case
   if (isParamSetByUser("mesh_only"))
     return;
 
   if (!_executor.get() && !_executioner.get())
   {
     if (!_early_exit_param.empty())
     {
       mooseAssert(_check_input,
                   "Something went wrong, we should only get here if _check_input is true.");
       mooseError(
           "Incompatible command line arguments provided. --check-input cannot be called with ",
           _early_exit_param,
           ".");
     }
     // We should never get here
     mooseError("The Executor is being called without being initialized. This is likely "
                "caused by "
                "incompatible command line arguments");
   }
 
   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 1079 of file MooseApp.h.

1079 { 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::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

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

◆ executeExecutioner()

void MooseApp::executeExecutioner ( )

virtual

Execute the Executioner that was built.

Definition at line 1207 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)
   {
     LibmeshPetscCall(Moose::PetscSupport::petscSetupOutput(_command_line.get()));
     _executor->init();
     errorCheck();
     auto result = _executor->exec();
     if (!result.convergedAll())
       mooseError(result.str());
   }
   else if (_executioner)
   {
     LibmeshPetscCall(Moose::PetscSupport::petscSetupOutput(_command_line.get()));
     _executioner->init();
     errorCheck();
     _executioner->execute();
   }
   else
     mooseError("No executioner was specified (go fix your input file)");
 }

◆ exitCode()

int MooseApp::exitCode ( ) const

inline

Get the shell exit code for the application.

Returns: The shell exit code

Definition at line 136 of file MooseApp.h.

Referenced by copyInputs().

136 { return _exit_code; }

MooseApp::_exit_code

int _exit_code

The exit code.

Definition: MooseApp.h:1258

◆ feProblem()

FEProblemBase & MooseApp::feProblem ( ) const

Definition at line 1396 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 1352 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 409 of file MooseApp.h.

Referenced by FixedPointSolve::FixedPointSolve().

409 { return _fixed_point_config; }

MooseApp::_fixed_point_config

FixedPointConfig _fixed_point_config

Multiapp-related fixed point algorithm configuration details primarily intended to be passed to and u...

Definition: MooseApp.h:1224

◆ getActionFactory()

ActionFactory& MooseApp::getActionFactory ( )

inline

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

Definition at line 429 of file MooseApp.h.

Referenced by Action::Action(), and DumpObjectsProblem::DumpObjectsProblem().

429 { return _action_factory; }

MooseApp::_action_factory

ActionFactory _action_factory

The Factory responsible for building Actions.

Definition: MooseApp.h:1176

◆ getChainControlDataSystem()

ChainControlDataSystem& MooseApp::getChainControlDataSystem ( )

inline

Gets the system that manages the ChainControls.

Definition at line 857 of file MooseApp.h.

Referenced by ChainControlSetupAction::act(), FEProblemBase::advanceState(), ChainControl::getChainControlDataSystem(), and ChainControlDataPostprocessor::initialSetup().

857 { return _chain_control_system; }

MooseApp::_chain_control_system

ChainControlDataSystem _chain_control_system

The system that manages the ChainControls.

Definition: MooseApp.h:1470

◆ getCheckpointDirectories()

std::list< std::string > MooseApp::getCheckpointDirectories ( ) const

Get all checkpoint directories.

Returns: A Set of checkpoint directories

Definition at line 1796 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 1828 of file MooseApp.C.

Referenced by setRestartRecoverFileBase().

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

◆ getCommunicator()

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

inline

Definition at line 1048 of file MooseApp.h.

Referenced by MooseServer::parseDocumentForDiagnostics().

1048 { return _comm; }

MooseApp::_comm

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

The MPI communicator this App is going to use.

Definition: MooseApp.h:1142

◆ 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 2501 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 483 of file MooseApp.h.

Referenced by MooseMesh::determineUseDistributedMesh().

483 { return _distributed_mesh_on_command_line; }

MooseApp::_distributed_mesh_on_command_line

bool _distributed_mesh_on_command_line

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

Definition: MooseApp.h:1267

◆ getExecuteOnEnum()

const ExecFlagEnum& MooseApp::getExecuteOnEnum ( ) const

inline

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

Definition at line 1030 of file MooseApp.h.

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

1030 { return _execute_flags; }

MooseApp::_execute_flags

const ExecFlagEnum _execute_flags

Execution flags for this App.

Definition: MooseApp.h:1481

◆ getExecutioner()

Executioner * MooseApp::getExecutioner ( ) const

Retrieve the Executioner for this App.

Definition at line 1552 of file MooseApp.C.

Referenced by CheckIntegrityAction::act(), AddTimeStepperAction::act(), ComposeTimeStepperAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), LazyCoupleable::coupled(), EigenProblem::doFreeNonlinearPowerIterations(), EigenKernel::EigenKernel(), PseudoTimestep::execute(), IterationInfo::execute(), PIDTransientControl::execute(), Terminator::execute(), ChangeOverFixedPointPostprocessor::finalize(), FVAdvection::FVAdvection(), DefaultNonlinearConvergence::getSharedExecutionerParam(), 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 347 of file MooseApp.h.

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

347 { return _executor.get(); }

MooseApp::_executor

std::shared_ptr< Executor > _executor

Pointer to the Executor of this run.

Definition: MooseApp.h:1212

◆ 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 1538 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 453 of file MooseApp.h.

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

453 { return _initial_from_file; }

MooseApp::_initial_from_file

bool _initial_from_file

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

Definition: MooseApp.h:1261

◆ getExReaderForRestart()

libMesh::ExodusII_IO* MooseApp::getExReaderForRestart ( ) const

inline

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

Definition at line 466 of file MooseApp.h.

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

466 { return _ex_reader.get(); }

MooseApp::_ex_reader

std::shared_ptr< libMesh::ExodusII_IO > _ex_reader

The Exodus reader when _initial_from_file is set to true.

Definition: MooseApp.h:1264

◆ getFactory()

Factory& MooseApp::getFactory ( )

inline

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

Definition at line 424 of file MooseApp.h.

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

424 { return _factory; }

MooseApp::_factory

Factory _factory

Definition: MooseApp.h:1250

◆ 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 1842 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 945 of file MooseApp.h.

945 { return _trap_fpe; }

MooseApp::_trap_fpe

bool _trap_fpe

Whether or not FPE trapping should be turned on.

Definition: MooseApp.h:1282

◆ getFrameworkVersion()

std::string MooseApp::getFrameworkVersion ( ) const

Returns the framework version.

Definition at line 718 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 324 of file MooseApp.h.

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

324 { return _global_time_offset; }

MooseApp::_global_time_offset

Real _global_time_offset

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

Definition: MooseApp.h:1163

◆ getInputFileNames()

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

Returns: the input file names set in the Parser

Definition at line 1098 of file MooseApp.C.

Referenced by ConsoleUtils::outputFrameworkInformation(), 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 2306 of file MooseApp.C.

Referenced by FEProblemBase::addMaterialHelper(), MooseBaseParameterInterface::connectControllableParams(), ActionFactory::create(), Factory::initialize(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), ConsoleUtils::outputDataFileParams(), 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 1657 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 1584 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 1105 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 2280 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;
 }

◆ getLibtorchDevice()

torch::DeviceType MooseApp::getLibtorchDevice ( ) const

inline

Get the device torch is supposed to be running on.

Definition at line 90 of file MooseApp.h.

90 { return _libtorch_device; }

MooseApp::_libtorch_device

const torch::DeviceType _libtorch_device

The libtorch device this app is using.

Definition: MooseApp.h:1512

◆ getLoadedLibraryPaths()

std::set< std::string > MooseApp::getLoadedLibraryPaths ( ) const

Return the paths of loaded libraries.

Definition at line 2269 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 886 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 894 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 904 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 852 of file MooseApp.h.

Referenced by ExecuteMeshGenerators::act(), SetupMeshAction::act(), CombineComponentsMeshes::act(), CreateAddedMeshGenerators::act(), CylinderComponent::addMeshGenerators(), BatchMeshGeneratorAction::addMeshGenerators(), MeshGenerator::checkGetMesh(), SideSetsFromNormalsGenerator::generate(), ExtraNodesetGenerator::generate(), MeshGenerator::getMeshByName(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::setupComponent(), and SetupDebugAction::SetupDebugAction().

852 { return _mesh_generator_system; }

MooseApp::_mesh_generator_system

MeshGeneratorSystem _mesh_generator_system

The system that manages the MeshGenerators.

Definition: MooseApp.h:1467

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

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

45 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:84

◆ getNullExecutor()

NullExecutor* MooseApp::getNullExecutor ( ) const

inline

Definition at line 348 of file MooseApp.h.

Referenced by ExecutorInterface::getExecutor().

348 { return _null_executor.get(); }

MooseApp::_null_executor

std::shared_ptr< NullExecutor > _null_executor

Used to return an executor that does nothing.

Definition: MooseApp.h:1231

◆ 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 1112 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 563 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 294 of file MooseApp.h.

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

294 { return _output_position; }

MooseApp::_output_position

Point _output_position

The output position.

Definition: MooseApp.h:1154

◆ getOutputWarehouse() [1/2]

OutputWarehouse & MooseApp::getOutputWarehouse ( )

Get the OutputWarehouse objects.

Definition at line 1848 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::outputFrameworkInformation(), ConsoleUtils::outputOutputInformation(), FEProblemBase::outputStep(), FEProblemBase::subdomainSetup(), and FEProblemBase::timestepSetup().

 {
   return _output_warehouse;
 }

◆ getOutputWarehouse() [2/2]

const OutputWarehouse & MooseApp::getOutputWarehouse ( ) const

Definition at line 1854 of file MooseApp.C.

 {
   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 1523 of file MooseApp.h.

Referenced by CommonOutputAction::act(), FEProblemBase::addOutput(), Console::Console(), MooseApp(), PerfGraphOutput::output(), Console::outputSystemInformation(), 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 1530 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 121 of file MooseApp.h.

Referenced by getPrintableVersion().

121 { return "Application"; }

◆ getPrintableVersion()

std::string MooseApp::getPrintableVersion ( ) const

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

Definition at line 730 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 738 of file MooseApp.h.

Referenced by restore().

738 { return _recoverable_data_names; }

MooseApp::_recoverable_data_names

DataNames _recoverable_data_names

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

Definition: MooseApp.h:1197

◆ getRecoverFileBase()

std::string MooseApp::getRecoverFileBase ( ) const

inline

Definition at line 518 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 2755 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 1537 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 704 of file MooseApp.h.

704 { return _restartable_data; }

MooseApp::_restartable_data

std::vector< RestartableDataMap > _restartable_data

Where the restartable data is held (indexed on tid)

Definition: MooseApp.h:1191

◆ getRestartableData() [2/2]

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

inline

Definition at line 705 of file MooseApp.h.

705 { return _restartable_data; }

MooseApp::_restartable_data

std::vector< RestartableDataMap > _restartable_data

Where the restartable data is held (indexed on tid)

Definition: MooseApp.h:1191

◆ getRestartableDataMap()

RestartableDataMap & MooseApp::getRestartableDataMap ( const RestartableDataMapName & name )

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

Definition at line 2863 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 1069 of file MooseApp.h.

Referenced by SetupDebugAction::act().

1069 { return _restartable_meta_data.begin(); }

MooseApp::_restartable_meta_data

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.

Definition: MooseApp.h:1442

◆ getRestartableDataMapEnd()

auto MooseApp::getRestartableDataMapEnd ( )

inline

Definition at line 1071 of file MooseApp.h.

Referenced by SetupDebugAction::act().

1071 { return _restartable_meta_data.end(); }

MooseApp::_restartable_meta_data

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.

Definition: MooseApp.h:1442

◆ getRestartableDataMapName()

const std::string & MooseApp::getRestartableDataMapName ( const RestartableDataMapName & name ) const

Returns: The output name for the restartable data with name name

Definition at line 2890 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 1950 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 517 of file MooseApp.h.

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

517 { return _restart_recover_base; }

MooseApp::_restart_recover_base

std::string _restart_recover_base

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

Definition: MooseApp.h:1285

◆ 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 2517 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 312 of file MooseApp.h.

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

312 { return _start_time; }

MooseApp::_start_time

Real _start_time

The time at which to start the simulation.

Definition: MooseApp.h:1160

◆ getSystemInfo()

const SystemInfo* MooseApp::getSystemInfo ( ) const

inline

Get SystemInfo object.

Returns: A pointer to the SystemInformation object

Definition at line 578 of file MooseApp.h.

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

578 { return _sys_info.get(); }

MooseApp::_sys_info

std::unique_ptr< SystemInfo > _sys_info

System Information.

Definition: MooseApp.h:1240

◆ getVersion()

std::string MooseApp::getVersion ( ) const

virtual

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

Definition at line 724 of file MooseApp.C.

Referenced by getPrintableVersion(), and ExodusFormatter::printInputFile().

 {
   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 1037 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 878 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 288 of file MooseApp.h.

Referenced by Exodus::output().

288 { return _output_position_set; }

MooseApp::_output_position_set

bool _output_position_set

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

Definition: MooseApp.h:1151

◆ hasRecoverFileBase()

bool MooseApp::hasRecoverFileBase ( ) const

Definition at line 1261 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 2404 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 2874 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 1940 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 1255 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 2509 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 307 of file MooseApp.h.

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

307 { return _start_time_set; }

MooseApp::_start_time_set

bool _start_time_set

Whether or not an start time has been set.

Definition: MooseApp.h:1157

◆ header()

std::string MooseApp::header ( ) const

virtual

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

Definition at line 2312 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 193 of file MooseApp.h.

Referenced by copyInputs(), errorCheck(), getRenamedParam(), MooseApp(), runInputFile(), runInputs(), SetupMeshAction::setupMesh(), and setupOptions().

193 { return _pars.isParamSetByUser(nm); }

InputParameters::isParamSetByUser

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

Method returns true if the parameter was by the user.

Definition: InputParameters.C:1173

MooseApp::_pars

InputParameters _pars

Parameters of this object.

Definition: MooseApp.h:1136

◆ isParamValid()

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

inline

Definition at line 191 of file MooseApp.h.

Referenced by getRenamedParam(), MooseApp(), setupOptions(), and Output::setWallTimeIntervalFromCommandLineParam().

191 { return _pars.isParamValid(name); }

MooseBase::name

virtual const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:57

MooseApp::_pars

InputParameters _pars

Parameters of this object.

Definition: MooseApp.h:1136

InputParameters::isParamValid

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

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

Definition: InputParameters.C:390

◆ 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 1237 of file MooseApp.C.

Referenced by ExecuteMeshGenerators::act(), SetupMeshCompleteAction::act(), SetupMeshAction::act(), SetupRecoverFileBaseAction::act(), OversampleOutput::cloneMesh(), MultiApp::createApp(), InversePowerMethod::execute(), NonlinearEigen::execute(), PIDTransientControl::execute(), SteadyBase::execute(), Eigenvalue::execute(), FullSolveMultiApp::FullSolveMultiApp(), NonlinearEigen::init(), InversePowerMethod::init(), TransientBase::init(), MooseMesh::init(), Console::initialSetup(), FEProblemBase::initialSetup(), OversampleOutput::outputStep(), Output::outputStep(), TransientBase::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 1243 of file MooseApp.C.

Referenced by SetupMeshAction::act(), FEProblemBase::checkICRestartError(), MultiApp::createApp(), EigenProblem::execute(), FileOutput::FileOutput(), FullSolveMultiApp::FullSolveMultiApp(), Eigenvalue::init(), FEProblemBase::initialSetup(), TransientBase::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 1249 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 837 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().

837 { return !_multiapp_level; }

MooseApp::_multiapp_level

unsigned int _multiapp_level

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

Definition: MooseApp.h:1455

◆ libNameToAppName()

std::string MooseApp::libNameToAppName ( const std::string & library_name ) const

Converts a library name to an application name:

Definition at line 1876 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 libMesh::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 2119 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 1984 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 847 of file MooseApp.h.

Referenced by SetupMeshAction::act().

847 { return _master_displaced_mesh; }

MooseApp::_master_displaced_mesh

const MooseMesh *const _master_displaced_mesh

The displaced mesh from master app.

Definition: MooseApp.h:1464

◆ masterMesh()

const MooseMesh* MooseApp::masterMesh ( ) const

inline

Returns a pointer to the master mesh.

Definition at line 842 of file MooseApp.h.

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

842 { return _master_mesh; }

MooseApp::_master_mesh

const MooseMesh *const _master_mesh

The mesh from master app.

Definition: MooseApp.h:1461

◆ 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 2485 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 826 of file MooseApp.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), MultiApp::createApp(), OutputWarehouse::mooseConsole(), ConsoleUtils::outputFrameworkInformation(), and Console::write().

826 { return _multiapp_level; }

MooseApp::_multiapp_level

unsigned int _multiapp_level

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

Definition: MooseApp.h:1455

◆ 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 832 of file MooseApp.h.

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

832 { return _multiapp_number; }

MooseApp::_multiapp_number

unsigned int _multiapp_number

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

Definition: MooseApp.h:1458

◆ name()

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

inlinevirtualinherited

Get the name of the class.

Returns: The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

57 { return _name; }

MooseBase::_name

const std::string _name

The name of this class.

Definition: MooseBase.h:90

◆ parameters()

InputParameters& MooseApp::parameters ( )

inline

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 147 of file MooseApp.h.

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

147 { return _pars; }

MooseApp::_pars

InputParameters _pars

Parameters of this object.

Definition: MooseApp.h:1136

◆ parser()

Parser & MooseApp::parser ( )

Returns: The Parser

Definition at line 1422 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 158 of file MooseApp.h.

Referenced by PerfGraphInterface::perfGraph().

158 { return _perf_graph; }

MooseApp::_perf_graph

PerfGraph & _perf_graph

The PerfGraph object for this application (recoverable)

Definition: MooseApp.h:1200

◆ 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 1969 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 790 of file MooseApp.h.

Referenced by restore().

790 {}

◆ preBackup()

virtual void MooseApp::preBackup ( )

inlinevirtual

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

Definition at line 756 of file MooseApp.h.

Referenced by backup().

756 {}

◆ processor_id()

processor_id_type MooseApp::processor_id ( ) const

inline

Returns the MPI processor ID of the current processor.

Definition at line 434 of file MooseApp.h.

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

434 { return _comm->rank(); }

MooseApp::_comm

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

The MPI communicator this App is going to use.

Definition: MooseApp.h:1142

◆ 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 153 of file MooseApp.h.

153 { return _rank_map; }

MooseApp::_rank_map

const RankMap _rank_map

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

Definition: MooseApp.h:1206

◆ 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 1429 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 1562 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 1888 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 2880 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 1269 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 1053 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 2532 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 2493 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 1310 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 1323 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 1345 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 1564 of file MooseApp.C.

 {
   TIME_SECTION("run", 3);
   if (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";
     _early_exit_param = "--docs";
     _ready_to_exit = true;
     return;
   }
 
   if (showInputs() || copyInputs() || runInputs())
   {
     _early_exit_param = "--show-input, --copy-inputs, or --run";
     _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 1137 of file MooseApp.C.

Referenced by run().

 {
   TIME_SECTION("runInputFile", 3);
 
   // If early exit param has been set, then just return
   if (_ready_to_exit)
     return;
 
   _action_warehouse.executeAllActions();
 
   if (isParamSetByUser("mesh_only"))
   {
     _early_exit_param = "--mesh-only";
     _ready_to_exit = true;
   }
   else if (isParamSetByUser("split_mesh"))
   {
     _early_exit_param = "--split-mesh";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("list_constructed_objects"))
   {
     // TODO: ask multiapps for their constructed objects
     _early_exit_param = "--list-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 ( )

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 1728 of file MooseApp.C.

Referenced by run().

 {
   if (isParamSetByUser("run"))
   {
     if (comm().size() > 1)
       mooseError("The --run option should not be ran in parallel");
 
     // Pass everything after --run on the cli to the TestHarness
     const auto find_run_it = std::as_const(*_command_line).findCommandLineParam("run");
     const auto & cl_entries = std::as_const(*_command_line).getEntries();
     mooseAssert(find_run_it != cl_entries.end(), "Didn't find the option");
     std::string test_args;
     for (auto it = std::next(find_run_it); it != cl_entries.end(); ++it)
       for (const auto & arg : it->raw_args)
       {
         test_args += " " + arg;
         libMesh::add_command_line_name(arg);
       }
 
     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.");
     }
 
     // Set this application as the app name for the moose_test_runner script that we're running
     setenv("MOOSE_TEST_RUNNER_APP_NAME", appBinaryName().c_str(), true);
 
     const std::string cmd = MooseUtils::runTestsExecutable() + test_args;
     Moose::out << "Working Directory: " << working_dir << "\nRunning Command: " << cmd << std::endl;
     mooseAssert(comm().size() == 1, "Should be run in serial");
     const auto return_value = system(cmd.c_str());
     if (!WIFEXITED(return_value))
       mooseError("Process exited unexpectedly");
     setExitCode(WEXITSTATUS(return_value));
     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 1384 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 1558 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 355 of file MooseApp.h.

Referenced by CreateExecutionerAction::act().

355 { _executioner = executioner; }

MooseApp::_executioner

std::shared_ptr< Executioner > _executioner

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

Definition: MooseApp.h:1209

◆ setExecutor()

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

inline

Definition at line 356 of file MooseApp.h.

356 { _executor = executor; }

MooseApp::_executor

std::shared_ptr< Executor > _executor

Pointer to the Executor of this run.

Definition: MooseApp.h:1212

◆ setExitCode()

void MooseApp::setExitCode ( const int exit_code )

inline

Sets the exit code that the application will exit with.

Definition at line 141 of file MooseApp.h.

Referenced by copyInputs(), and runInputs().

141 { _exit_code = exit_code; }

MooseApp::_exit_code

int _exit_code

The exit code.

Definition: MooseApp.h:1258

◆ 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 447 of file MooseApp.h.

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

447 { _initial_from_file = flag; }

MooseApp::_initial_from_file

bool _initial_from_file

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

Definition: MooseApp.h:1261

◆ setExReaderForRestart()

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

inline

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

Definition at line 458 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 318 of file MooseApp.h.

318 { _global_time_offset = offset; }

MooseApp::_global_time_offset

Real _global_time_offset

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

Definition: MooseApp.h:1163

◆ 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 1121 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 551 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 1785 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 2324 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 2318 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 529 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 1835 of file MooseApp.C.

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

 {
   _start_time_set = true;
   _start_time = time;
 }

◆ setupOptions()

void MooseApp::setupOptions ( )

virtual

Setup options based on InputParameters.

Definition at line 736 of file MooseApp.C.

Referenced by run().

 {
   TIME_SECTION("setupOptions", 5, "Setting Up Options");
 
   // Print the header, this is as early as possible
   if (header().length() && !getParam<bool>("suppress_header"))
     _console << header() << 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");
 
   // The no_timing flag takes precedence over the timing flag.
   if (getParam<bool>("no_timing"))
     _pars.set<bool>("timing") = false;
 
   if (getParam<bool>("trap_fpe"))
   {
     _trap_fpe = true;
     _perf_graph.setActive(false);
     if (getParam<bool>("no_trap_fpe"))
       mooseError("Cannot use both \"--trap-fpe\" and \"--no-trap-fpe\" flags.");
   }
   else if (getParam<bool>("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
   {
     // Set from command line
     auto color = getParam<MooseEnum>("color");
     if (!isParamSetByUser("color"))
     {
       // Set from deprecated --no-color
       if (getParam<bool>("no_color"))
         color = "off";
       // Set from environment
       else
       {
         char * c_color = std::getenv("MOOSE_COLOR");
         if (c_color)
           color.assign(std::string(c_color), "While assigning environment variable MOOSE_COLOR");
       }
     }
 
     if (color == "auto")
       Moose::setColorConsole(true);
     else if (color == "on")
       Moose::setColorConsole(true, true);
     else if (color == "off")
       Moose::setColorConsole(false);
     else
       mooseAssert(false, "Should not hit");
 
     // After setting color so that non-yellow deprecated is honored
     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;
     _early_exit_param = "--version";
     _ready_to_exit = true;
     return;
   }
   else if (getParam<bool>("help"))
   {
     _command_line->printUsage();
     _early_exit_param = "--help";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("dump") || isParamSetByUser("dump_search"))
   {
     const std::string search =
         isParamSetByUser("dump_search") ? getParam<std::string>("dump_search") : "";
 
     JsonSyntaxTree tree(search);
 
     {
       TIME_SECTION("dump", 1, "Building Syntax Tree");
       _builder.buildJsonSyntaxTree(tree);
     }
 
     // Check if second arg is valid or not
     if ((tree.getRoot()).is_object())
     {
       // 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;
       _early_exit_param = "--dump";
       _ready_to_exit = true;
     }
     else
       mooseError("Search parameter '", search, "' was not found in the registered syntax.");
   }
   else if (getParam<bool>("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";
     }
     _early_exit_param = "--registry";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("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";
     _early_exit_param = "--registry_hit";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("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";
     _early_exit_param = "--definition";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("yaml") || isParamSetByUser("yaml_search"))
   {
     const std::string search =
         isParamSetByUser("yaml_search") ? getParam<std::string>("yaml_search") : "";
     _perf_graph.disableLivePrint();
 
     _builder.initSyntaxFormatter(Moose::Builder::YAML, true);
     _builder.buildFullTree(search);
 
     _early_exit_param = "--yaml";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("json") || isParamSetByUser("json_search"))
   {
     const std::string search =
         isParamSetByUser("json_search") ? getParam<std::string>("json_search") : "";
     _perf_graph.disableLivePrint();
 
     JsonSyntaxTree tree(search);
     _builder.buildJsonSyntaxTree(tree);
 
     Moose::out << "**START JSON DATA**\n" << tree.getRoot().dump(2) << "\n**END JSON DATA**\n";
     _early_exit_param = "--json";
     _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;
     _early_exit_param = "--syntax";
     _ready_to_exit = true;
   }
   else if (getParam<bool>("show_type"))
   {
     _perf_graph.disableLivePrint();
 
     Moose::out << "MooseApp Type: " << type() << std::endl;
     _early_exit_param = "--show-type";
     _ready_to_exit = true;
   }
   else if (getInputFileNames().size())
   {
     if (isParamSetByUser("recover"))
     {
       // We need to set the flag manually here since the recover parameter is a string type (takes
       // an optional filename)
       _recover = true;
       const auto & recover = getParam<std::string>("recover");
       if (recover.size())
         _restart_recover_base = recover;
     }
 
     // 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 (isParamSetByUser("mesh_only"))
     {
       // If we are looking to just check the input, there is no need to
       // call MeshOnlyAction and generate a mesh
       if (_check_input)
         _action_warehouse.setFinalTask("setup_mesh_complete");
       else
       {
         _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 (isParamSetByUser("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.
         // use proximate here because the input file is an absolute path
         const auto & 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
     }
   }
   // No input file provided but we have other arguments (so don't just show print usage)
   else if (!isParamSetByUser("input_file") && _command_line->getArguments().size() > 2)
   {
     mooseAssert(getInputFileNames().empty(), "Should be empty");
 
     if (_check_input)
       mooseError("You specified --check-input, but did not provide an input file. Add -i "
                  "<inputfile> to your command line.");
 
     mooseError("No input files specified. Add -i <inputfile> to your command line.");
   }
   else if (isParamValid("language_server") && getParam<bool>("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();
 
     _early_exit_param = "--language-server";
     _ready_to_exit = true;
   }
 
   else /* The catch-all case for bad options or missing options, etc. */
   {
     _command_line->printUsage();
     _early_exit_param = "bad or missing";
     _ready_to_exit = true;
     _exit_code = 1;
   }
 
   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 1625 of file MooseApp.C.

Referenced by run().

 {
   if (getParam<bool>("show_inputs"))
   {
     const auto show_inputs_syntax = _pars.getCommandLineMetadata("show_inputs").switches;
     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(!show_inputs_syntax.empty(), "show_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 \""
                  << show_inputs_syntax[0] << "\" flag. e.g.:\n$ "
                  << _command_line->getExecutableName() << ' ' << show_inputs_syntax[0] << ' '
                  << dirs[0] << '\n';
     }
     return true;
   }
   return false;
 }

◆ solutionInvalidity() [1/2]

SolutionInvalidity& MooseApp::solutionInvalidity ( )

inline

Get the SolutionInvalidity for this app.

Definition at line 164 of file MooseApp.h.

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

164 { return _solution_invalidity; }

MooseApp::_solution_invalidity

SolutionInvalidity & _solution_invalidity

The SolutionInvalidity object for this application.

Definition: MooseApp.h:1203

◆ solutionInvalidity() [2/2]

const SolutionInvalidity& MooseApp::solutionInvalidity ( ) const

inline

Definition at line 165 of file MooseApp.h.

165 { return _solution_invalidity; }

MooseApp::_solution_invalidity

SolutionInvalidity & _solution_invalidity

The SolutionInvalidity object for this application.

Definition: MooseApp.h:1203

◆ syntax()

Syntax& MooseApp::syntax ( )

inline

Returns a writable reference to the syntax object.

Definition at line 237 of file MooseApp.h.

Referenced by dynamicAllRegistration(), and setupOptions().

237 { return _syntax; }

MooseApp::_syntax

Syntax _syntax

Syntax of the input file.

Definition: MooseApp.h:1169

◆ testCheckpointHalfTransient()

bool MooseApp::testCheckpointHalfTransient ( ) const

inline

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

Definition at line 541 of file MooseApp.h.

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

541 { return _test_checkpoint_half_transient; }

MooseApp::_test_checkpoint_half_transient

bool _test_checkpoint_half_transient

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

Definition: MooseApp.h:1288

◆ theWarehouse()

TheWarehouse& MooseApp::theWarehouse ( )

inline

Definition at line 116 of file MooseApp.h.

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

116 { return *_the_warehouse; }

MooseApp::_the_warehouse

std::unique_ptr< TheWarehouse > _the_warehouse

The combined warehouse for storing any MooseObject based object.

Definition: MooseApp.h:1452

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

51 { return _type; }

MooseBase::_type

const std::string _type

The type of this class.

Definition: MooseBase.h:87

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

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

Definition at line 27 of file MooseBase.C.

Referenced by 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 419 of file MooseApp.h.

Referenced by CreateProblemDefaultAction::act().

419 { return _use_eigen_value; }

MooseApp::_use_eigen_value

bool _use_eigen_value

Boolean to indicate whether to use an eigenvalue executioner.

Definition: MooseApp.h:1237

◆ useExecutor()

bool MooseApp::useExecutor ( ) const

inline

Definition at line 349 of file MooseApp.h.

349 { return _use_executor; }

MooseApp::_use_executor

const bool _use_executor

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

Definition: MooseApp.h:1228

◆ useNonlinear()

bool& MooseApp::useNonlinear ( )

inline

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

Definition at line 414 of file MooseApp.h.

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

414 { return _use_nonlinear; }

MooseApp::_use_nonlinear

bool _use_nonlinear

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

Definition: MooseApp.h:1234

◆ validParams()

InputParameters MooseApp::validParams ( )

static

Definition at line 104 of file MooseApp.C.

 {
   InputParameters params = emptyInputParameters();
 
   MooseApp::addAppParam(params);
   MooseApp::addInputParam(params);
 
   params.addCommandLineParam<bool>("display_version", "-v --version", "Print application version");
 
   params.addOptionalValuedCommandLineParam<std::string>(
       "mesh_only",
       "--mesh-only <optional path>",
       "",
       "Build and output the mesh only (Default: \"<input_file_name>_in.e\")");
 
   params.addCommandLineParam<bool>(
       "show_input", "--show-input", "Shows the parsed input file before running the simulation");
   params.setGlobalCommandLineParam("show_input");
   params.addCommandLineParam<bool>(
       "show_outputs", "--show-outputs", "Shows the output execution time information");
   params.setGlobalCommandLineParam("show_outputs");
   params.addCommandLineParam<bool>(
       "show_controls", "--show-controls", "Shows the Control logic available and executed");
   params.setGlobalCommandLineParam("show_controls");
 
   params.addCommandLineParam<bool>(
       "no_color", "--no-color", "Disable coloring of all Console outputs");
   params.setGlobalCommandLineParam("no_color");
 
   MooseEnum colors("auto on off", "on");
   params.addCommandLineParam<MooseEnum>(
       "color", "--color <auto,on,off=on>", colors, "Whether to use color in console output");
   params.setGlobalCommandLineParam("color");
 
   params.addCommandLineParam<bool>("help", "-h --help", "Displays CLI usage statement");
   params.addCommandLineParam<bool>(
       "minimal",
       "--minimal",
       "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<bool>(
       "definition", "--definition", "Shows a SON style input definition dump for input validation");
   params.addCommandLineParam<bool>("dump", "--dump", "Shows a dump of available input file syntax");
   params.addCommandLineParam<std::string>(
       "dump_search",
       "--dump-search <search>",
       "Shows a dump of available input syntax matching a search");
   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", "Use the new Executor system instead of Executioners");
 
   params.addCommandLineParam<bool>(
       "show_type", "--show-type", "Return the name of the application object");
   params.addCommandLineParam<bool>("yaml", "--yaml", "Dumps all input file syntax in YAML format");
   params.addCommandLineParam<std::string>(
       "yaml_search", "--yaml-search", "Dumps input file syntax matching a search in YAML format");
   params.addCommandLineParam<bool>("json", "--json", "Dumps all input file syntax in JSON format");
   params.addCommandLineParam<std::string>(
       "json_search", "--json-search", "Dumps input file syntax matching a search in JSON format");
   params.addCommandLineParam<bool>(
       "syntax", "--syntax", "Dumps the associated Action syntax paths ONLY");
   params.addCommandLineParam<bool>(
       "show_docs", "--docs", "Print url/path to the documentation website");
   params.addCommandLineParam<bool>("check_input",
                                    "--check-input",
                                    "Check the input file (i.e. requires -i <filename>) and quit");
   params.setGlobalCommandLineParam("check_input");
   params.addCommandLineParam<bool>(
       "show_inputs",
       "--show-copyable-inputs",
       "Shows the directories able to be copied into a user-writable location");
 
   params.addCommandLineParam<std::string>(
       "copy_inputs",
       "--copy-inputs <dir>",
       "Copies installed inputs (e.g. tests, examples, etc.) to a directory <appname>_<dir>");
   // TODO: Should this remain a bool? It can't be a regular argument because it contains
   // values that have dashes in it, so it'll get treated as another arg
   params.addOptionalValuedCommandLineParam<std::string>(
       "run",
       "--run <test harness args>",
       "",
       "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",
       "List all moose object type names constructed by the master app factory");
 
   params.addCommandLineParam<unsigned int>(
       "n_threads", "--n-threads=<n>", "Runs the specified number of threads per process");
   // This probably shouldn't be global, but the implications of removing this are currently
   // unknown and we need to manage it with libmesh better
   params.setGlobalCommandLineParam("n_threads");
 
   params.addCommandLineParam<bool>("allow_unused",
                                    "-w --allow-unused",
                                    "Warn about unused input file options instead of erroring");
   params.setGlobalCommandLineParam("allow_unused");
   params.addCommandLineParam<bool>(
       "error_unused", "-e --error-unused", "Error when encountering unused input file options");
   params.setGlobalCommandLineParam("error_unused");
   params.addCommandLineParam<bool>(
       "error_override",
       "-o --error-override",
       "Error when encountering overridden or parameters supplied multiple times");
   params.setGlobalCommandLineParam("error_override");
   params.addCommandLineParam<bool>(
       "error_deprecated", "--error-deprecated", "Turn deprecated code messages into Errors");
   params.setGlobalCommandLineParam("error_deprecated");
 
   params.addCommandLineParam<bool>("distributed_mesh",
                                    "--distributed-mesh",
                                    "Forces the use of a distributed finite element mesh");
   // Would prefer that this parameter isn't global, but we rely on it too much
   // in tests to be able to go back on that decision now
   params.setGlobalCommandLineParam("distributed_mesh");
 
   params.addCommandLineParam<std::string>(
       "split_mesh",
       "--split-mesh <splits>",
       "Comma-separated list of numbers of chunks to split the mesh into");
 
   // TODO: remove the logic now that this is global
   params.addCommandLineParam<std::string>(
       "split_file", "--split-file <filename>", "Name of split mesh file(s) to write/read");
 
   params.addCommandLineParam<bool>("use_split", "--use-split", "Use split distributed mesh files");
 
   params.addCommandLineParam<unsigned int>(
       "refinements", "-r <num refinements>", "Specify additional initial uniform mesh refinements");
 
   params.addOptionalValuedCommandLineParam<std::string>(
       "recover",
       "--recover <optional file base>",
       "",
       "Continue the calculation. Without <file base>, the most recent recovery file will be used");
   params.setGlobalCommandLineParam("recover");
 
   params.addCommandLineParam<bool>("suppress_header",
                                    "--suppress-header",
                                    false,
                                    "Disables the output of the application header.");
   params.setGlobalCommandLineParam("suppress_header");
 
   params.addCommandLineParam<bool>(
       "test_checkpoint_half_transient",
       "--test-checkpoint-half-transient",
       "Run half of a transient with checkpoints enabled; used by the TestHarness");
   params.setGlobalCommandLineParam("test_checkpoint_half_transient");
 
   params.addCommandLineParam<bool>(
       "trap_fpe",
       "--trap-fpe",
       "Enable floating point exception handling in critical sections of code"
 #ifdef DEBUG
       " (automatic due to debug build)"
 #endif
   );
   params.setGlobalCommandLineParam("trap_fpe");
 
   params.addCommandLineParam<bool>(
       "no_trap_fpe",
       "--no-trap-fpe",
       "Disable floating point exception handling in critical sections of code"
 #ifndef DEBUG
       " (unused due to non-debug build)"
 #endif
   );
 
   params.setGlobalCommandLineParam("no_trap_fpe");
 
   params.addCommandLineParam<bool>(
       "no_gdb_backtrace", "--no-gdb-backtrace", "Disables gdb backtraces.");
   params.setGlobalCommandLineParam("no_gdb_backtrace");
 
   params.addCommandLineParam<bool>("error", "--error", "Turn all warnings into errors");
   params.setGlobalCommandLineParam("error");
 
   params.addCommandLineParam<bool>("timing",
                                    "-t --timing",
                                    "Enable all performance logging for timing; disables screen "
                                    "output of performance logs for all Console objects");
   params.setGlobalCommandLineParam("timing");
   params.addCommandLineParam<bool>(
       "no_timing", "--no-timing", "Disabled performance logging; overrides -t or --timing");
   params.setGlobalCommandLineParam("no_timing");
 
   params.addCommandLineParam<bool>(
       "allow_test_objects", "--allow-test-objects", "Register test objects and syntax");
   params.setGlobalCommandLineParam("allow_test_objects");
 
   // 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",
       "Keep standard output from all processors when running in parallel");
   params.setGlobalCommandLineParam("keep_cout");
   params.addCommandLineParam<bool>(
       "redirect_stdout",
       "--redirect-stdout",
       "Keep standard output from all processors when running in parallel");
   params.setGlobalCommandLineParam("redirect_stdout");
 
   params.addCommandLineParam<std::string>(
       "timpi_sync",
       "--timpi-sync <type=nbx>",
       "nbx",
       "Changes the sync type used in spare parallel communitations within TIMPI");
   params.setGlobalCommandLineParam("timpi_sync");
 
   // 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 <debugger>");
 
   params.addCommandLineParam<unsigned int>(
       "stop_for_debugger",
       "--stop-for-debugger <seconds>",
       "Pauses the application during startup for <seconds> to allow for connection of debuggers");
 
   params.addCommandLineParam<bool>(
       "perf_graph_live_all", "--perf-graph-live-all", "Forces printing of ALL progress messages");
   params.setGlobalCommandLineParam("perf_graph_live_all");
 
   params.addCommandLineParam<bool>(
       "disable_perf_graph_live", "--disable-perf-graph-live", "Disables PerfGraph live printing");
   params.setGlobalCommandLineParam("disable_perf_graph_live");
 
   params.addParam<bool>(
       "automatic_automatic_scaling", false, "Whether to turn on automatic scaling by default");
 
   MooseEnum libtorch_device_type("cpu cuda mps", "cpu");
   params.addCommandLineParam<MooseEnum>("libtorch_device",
                                         "--libtorch-device",
                                         libtorch_device_type,
                                         "The device type we want to run libtorch on.");
 
 #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.addCommandLineParam<bool>(
       "show_data_params",
       "--show-data-params",
       false,
       "Show found paths for all DataFileName parameters in the header");
   params.addCommandLineParam<bool>("show_data_paths",
                                    "--show-data-paths",
                                    false,
                                    "Show registered data paths for searching in the header");
 
   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_behavior",
       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 1991 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 2005 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 1516 of file MooseApp.h.

◆ Restartable

friend class Restartable

friend

Definition at line 1517 of file MooseApp.h.

◆ SubProblem

friend class SubProblem

friend

Definition at line 1518 of file MooseApp.h.

Member Data Documentation

◆ _action_factory

ActionFactory MooseApp::_action_factory

protected

The Factory responsible for building Actions.

Definition at line 1176 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 1179 of file MooseApp.h.

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

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), ElementIDOutputAction::act(), CreateExecutionerAction::act(), DeclareLateReportersAction::act(), AddExecutorAction::act(), AddMeshGeneratorAction::act(), AutoCheckpointAction::act(), ExecuteMeshGenerators::act(), CheckIntegrityAction::act(), ReadExecutorParamsAction::act(), CopyNodalVarsAction::act(), SetupMeshCompleteAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), CombineComponentsMeshes::act(), AddTimeStepperAction::act(), SetupDebugAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), ComposeTimeStepperAction::act(), SetupRecoverFileBaseAction::act(), CouplingFunctorCheckAction::act(), AddRelationshipManager::act(), SetAdaptivityOptionsAction::act(), CreateAddedMeshGenerators::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), ResolveOptionalMaterialPropertiesAction::act(), CommonOutputAction::act(), AddPeriodicBCAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), CylinderComponent::addMeshGenerators(), BatchMeshGeneratorAction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addMultiApp(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FVFluxKernel::adjustRMGhostLayers(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), MooseBase::callMooseError(), CheckOutputAction::checkConsoleOutput(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), CheckOutputAction::checkMaterialOutput(), CheckOutputAction::checkPerfLogOutput(), CheckOutputAction::checkVariableOutput(), SingleRankPartitioner::clone(), RandomPartitioner::clone(), BlockWeightedPartitioner::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), LibmeshPartitioner::clone(), PetscExternalPartitioner::clone(), HierarchicalGridPartitioner::clone(), GridPartitioner::clone(), ElementSideNeighborLayers::clone(), ElementPointNeighborLayers::clone(), RedistributeProperties::clone(), GhostBoundary::clone(), ProxyRelationshipManager::clone(), OversampleOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), MultiApp::createApp(), MultiApp::createApps(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), InversePowerMethod::execute(), NonlinearEigen::execute(), PseudoTimestep::execute(), IterationInfo::execute(), PIDTransientControl::execute(), TransientBase::execute(), SteadyBase::execute(), Eigenvalue::execute(), EigenProblem::execute(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), ExtraNodesetGenerator::generate(), SideSetsFromNormalsGenerator::generate(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), MooseBase::getMooseApp(), NumRelationshipManagers::getValue(), NumFixedPointIterations::getValue(), GhostingUserObject::GhostingUserObject(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), Eigenvalue::init(), MooseMesh::init(), FEProblemBase::init(), TimePeriod::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), EigenProblem::initPetscOutputAndSomeSolverSettings(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MeshGenerator::MeshGenerator(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), PerfGraphOutput::output(), Tecplot::output(), Exodus::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(), TransientBase::preExecute(), PhysicsBase::prepareCopyVariablesFromMesh(), Eigenvalue::prepareSolverOptions(), FEProblemBase::projectSolution(), TiledMesh::safeClone(), FileMesh::safeClone(), ImageMesh::safeClone(), RinglebMesh::safeClone(), AnnularMesh::safeClone(), GeneratedMesh::safeClone(), SpiralAnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), MeshGeneratorMesh::safeClone(), StitchedMesh::safeClone(), PatternedMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), MeshGeneratorComponent::setupComponent(), SetupMeshAction::setupMesh(), TimeSequenceStepperBase::setupSequence(), TransientBase::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(), TransientBase::TransientBase(), 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 1301 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 1487 of file MooseApp.h.

Referenced by defaultAutomaticScaling().

◆ _builder

Moose::Builder MooseApp::_builder

protected

Builder for building app related parser tree.

Definition at line 1188 of file MooseApp.h.

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

◆ _chain_control_system

ChainControlDataSystem MooseApp::_chain_control_system

private

The system that manages the ChainControls.

Definition at line 1470 of file MooseApp.h.

Referenced by getChainControlDataSystem().

◆ _check_input

bool MooseApp::_check_input

protected

true if we want to just check the input file

Definition at line 1294 of file MooseApp.h.

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

◆ _comm

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

protected

The MPI communicator this App is going to use.

Definition at line 1142 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 1166 of file MooseApp.h.

Referenced by commandLine(), copyInputs(), executeExecutioner(), MooseApp(), 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.

◆ _cpu_profiling

bool MooseApp::_cpu_profiling = false

private

CPU profiling.

Definition at line 1490 of file MooseApp.h.

Referenced by 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 1267 of file MooseApp.h.

Referenced by getDistributedMeshOnCommandLine(), and setupOptions().

◆ _early_exit_param

std::string MooseApp::_early_exit_param

protected

Indicates if simulation is ready to exit, and keeps track of which param caused it to exit.

Definition at line 1255 of file MooseApp.h.

Referenced by errorCheck(), run(), runInputFile(), 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 1253 of file MooseApp.h.

Referenced by setErrorOverridden().

◆ _ex_reader

std::shared_ptr<libMesh::ExodusII_IO> MooseApp::_ex_reader

protected

The Exodus reader when _initial_from_file is set to true.

Definition at line 1264 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 1481 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 1209 of file MooseApp.h.

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

◆ _executor

std::shared_ptr<Executor> MooseApp::_executor

protected

Pointer to the Executor of this run.

Definition at line 1212 of file MooseApp.h.

Referenced by attachRelationshipManagers(), createExecutors(), errorCheck(), 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 1220 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 1215 of file MooseApp.h.

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

◆ _exit_code

int MooseApp::_exit_code

protected

The exit code.

Definition at line 1258 of file MooseApp.h.

Referenced by exitCode(), setExitCode(), and setupOptions().

◆ _factory

Factory MooseApp::_factory

protected

Definition at line 1250 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 1148 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 1224 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 1163 of file MooseApp.h.

Referenced by getGlobalTimeOffset(), and setGlobalTimeOffset().

◆ _heap_profiling

bool MooseApp::_heap_profiling = false

private

Memory profiling.

Definition at line 1493 of file MooseApp.h.

Referenced by 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 1508 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 1261 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 1173 of file MooseApp.h.

Referenced by getInputParameterWarehouse().

◆ _interface_registry

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

private

Registration for interface objects.

Definition at line 1502 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 1318 of file MooseApp.h.

Referenced by getLoadedLibraryPaths(), and loadLibraryAndDependencies().

◆ _libtorch_device

const torch::DeviceType MooseApp::_libtorch_device

private

The libtorch device this app is using.

Definition at line 1512 of file MooseApp.h.

◆ _master_displaced_mesh

const MooseMesh* const MooseApp::_master_displaced_mesh

private

The displaced mesh from master app.

Definition at line 1464 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 1461 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 1467 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 1455 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 1458 of file MooseApp.h.

Referenced by multiAppNumber().

◆ _name

const std::string MooseBase::_name

protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

◆ _null_executor

std::shared_ptr<NullExecutor> MooseApp::_null_executor

protected

Used to return an executor that does nothing.

Definition at line 1231 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 1484 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 1145 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 1291 of file MooseApp.h.

Referenced by getOutputFileNumbers(), and setOutputFileNumbers().

◆ _output_position

Point MooseApp::_output_position

protected

The output position.

Definition at line 1154 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 1151 of file MooseApp.h.

Referenced by hasOutputPosition(), and setOutputPosition().

◆ _output_warehouse

OutputWarehouse MooseApp::_output_warehouse

protected

OutputWarehouse object for this App.

Definition at line 1182 of file MooseApp.h.

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

◆ _pars

InputParameters MooseApp::_pars

protected

Parameters of this object.

Definition at line 1136 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 1185 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 1200 of file MooseApp.h.

Referenced by MooseApp(), 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 1206 of file MooseApp.h.

Referenced by rankMap().

◆ _rd_reader

RestartableDataReader MooseApp::_rd_reader

private

Definition at line 1472 of file MooseApp.h.

Referenced by finalizeRestore(), and restore().

◆ _ready_to_exit

bool MooseApp::_ready_to_exit

protected

Definition at line 1256 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 1270 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 1197 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 1297 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 1273 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 1285 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 1191 of file MooseApp.h.

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

◆ _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 1442 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 1203 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 1276 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 1160 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 1157 of file MooseApp.h.

Referenced by hasStartTime(), and setStartTime().

◆ _syntax

Syntax MooseApp::_syntax

protected

Syntax of the input file.

Definition at line 1169 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 1240 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 1499 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 1288 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 1452 of file MooseApp.h.

Referenced by MooseApp(), and theWarehouse().

◆ _trap_fpe

bool MooseApp::_trap_fpe

protected

Whether or not FPE trapping should be turned on.

Definition at line 1282 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 1139 of file MooseApp.h.

Referenced by MooseApp().

◆ _undisp_to_disp_rms

std::unordered_map<RelationshipManager *, std::shared_ptr<libMesh::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 1308 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 1237 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 1228 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 1234 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 1279 of file MooseApp.h.

◆ MESH_META_DATA

const RestartableDataMapName MooseApp::MESH_META_DATA = "MeshMetaData"

static

Definition at line 109 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 110 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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ RegistrationType

◆ UNUSED_CHECK

Constructor & Destructor Documentation

◆ ~MooseApp()

◆ MooseApp()

Member Function Documentation

◆ actionWarehouse() [1/2]

◆ actionWarehouse() [2/2]

◆ addAppParam()

◆ addExecutor()

◆ addExecutorParams()

◆ addInputParam()

◆ addMeshGenerator()

◆ addRelationshipManager()

◆ appBinaryName()

◆ appendMeshGenerator()

◆ appNameToLibName()

◆ attachRelationshipManagers() [1/2]

◆ attachRelationshipManagers() [2/2]

◆ backup() [1/2]

◆ backup() [2/2]

◆ builder()

◆ callMooseError()

◆ checkInput()

◆ checkMetaDataIntegrity()

◆ checkpointSuffix()

◆ commandLine()

◆ constructingMeshGenerators()

◆ copyInputs()

◆ createExecutors()

◆ createMinimalApp()

◆ createRecoverablePerfGraph()

◆ createRecoverableSolutionInvalidity()

◆ createRMFromTemplateAndInit()

◆ defaultAutomaticScaling()

◆ determineLibtorchDeviceType()

◆ disableCheckUnusedFlag()

◆ dynamicAllRegistration()

◆ dynamicAppRegistration()

◆ dynamicRegistration()

◆ errorCheck()

◆ errorOnJacobianNonzeroReallocation()

◆ errorPrefix()

◆ executeExecutioner()

◆ exitCode()

◆ feProblem()

◆ finalizeRestore()

◆ fixedPointConfig()

◆ getActionFactory()

◆ getChainControlDataSystem()

◆ getCheckpointDirectories()

◆ getCheckpointFiles()

◆ getCommunicator()

◆ getCurrentActionHitNode()

◆ getDistributedMeshOnCommandLine()

◆ getExecuteOnEnum()

◆ getExecutioner()

◆ getExecutor() [1/2]

◆ getExecutor() [2/2]

◆ getExodusFileRestart()

◆ getExReaderForRestart()

◆ getFactory()

◆ getFileName()

◆ getFPTrapFlag()

◆ getFrameworkVersion()

◆ getGlobalTimeOffset()