MooseApp Class Reference

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

#include <MooseApp.h>

Inheritance diagram for MooseApp:

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

Public Member Functions
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...
const InputParameters &	parameters ()
	Get the parameters of the object. More...
const RankMap &	rankMap ()
	The RankMap is a useful object for determining how the processes are laid out on the physical nodes of the cluster. More...
PerfGraph &	perfGraph ()
	Get the PerfGraph for this app. More...
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...
bool	useMasterMesh () const
	Returns whether to use the parent app mesh as the mesh for this 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...
bool	forceRestart () const
	Whether or not we are forcefully restarting (allowing the load of potentially incompatibie checkpoints); used within RestartableDataReader. More...
bool	unusedFlagIsWarning () const
	Returns whether the flag for unused parameters is set to throw a warning only. More...
bool	unusedFlagIsError () const
	Returns whether the flag for unused parameters is set to throw an error. More...
void	setMFEMDevice (const std::string &device_string, Moose::PassKey< MFEMExecutioner >)
	Create/configure the MFEM device with the provided device_string. More...
std::shared_ptr< mfem::Device >	getMFEMDevice (Moose::PassKey< MultiApp >)
	Get the MFEM device object. More...
const std::set< std::string > &	getMFEMDevices (Moose::PassKey< MultiApp >) const
	Get the configured MFEM devices. 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 (const 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...
void	outputMachineReadableData (const std::string &param, const std::string &start_marker, const std::string &end_marker, const std::string &data) const
	Outputs machine readable data (JSON, YAML, etc.) either to the screen (if no filename was provided as an argument to the parameter param) or to a file (if a filename was provided). 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

Static Protected Member Functions
static void	addCapability (const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
	register a new capability More...
static void	addCapability (const std::string &capability, const char *value, const std::string &doc)

Protected Attributes
const 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...
const bool	_force_restart
	Whether or not we are forcefully attempting to load checkpoints (–force-restart) 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	registerCapabilities ()
	Register all base MooseApp capabilities to the Moose::Capabilities registry. 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 bool	_use_master_mesh
	Whether to use the parent app mesh for this app. 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...
std::shared_ptr< mfem::Device >	_mfem_device
	The MFEM Device object. More...
std::set< std::string >	_mfem_devices
	MFEM supported devices based on user-provided config. 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 96 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 1516 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 1270 of file MooseApp.h.

  {
    OFF,
    WARN_UNUSED,
    ERROR_UNUSED
  } _enable_unused_check;

Constructor & Destructor Documentation

~MooseApp()

MooseApp::~MooseApp ( )

virtual

Definition at line 1169 of file MooseApp.C.

{
#ifdef HAVE_GPERFTOOLS
  // CPU profiling stop
  if (_cpu_profiling)
    ProfilerStop();
  // Heap profiling stop
  if (_heap_profiling)
    HeapProfilerStop();
#endif
  _action_warehouse.clear();
  _the_warehouse.reset();
  _executioner.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();

  // Remove this app's parameters from the AppFactory
  AppFactory::instance().clearAppParams(parameters(), {});

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

MooseApp()

MooseApp::MooseApp ( const InputParameters &  parameters )

protected

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

Definition at line 435 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
    // The use of AppFactory::getAppParams() is atrocious. However, a long time ago
    // we decided to copy construct parameters in each derived application...
    // which means that the "parameters" we get if someone derives from MooseApp are
    // actually a copy of the ones built by the factory. Because we have unique
    // application names, this allows us to reference (using _pars and MooseBase)
    // the actual const parameters that the AppFactory made for this application
    MooseBase(AppFactory::instance().getAppParams(parameters).get<std::string>("_type"),
              AppFactory::instance().getAppParams(parameters).get<std::string>("_app_name"),
              *this,
              AppFactory::instance().getAppParams(parameters)),
    _pars(AppFactory::instance().getAppParams(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(_pars.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(_pars.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(_pars.get<bool>("use_split")),
    _force_restart(_pars.get<bool>("force_restart")),
#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") ? _pars.get<unsigned int>("_multiapp_level")
                                                    : 0),
    _multiapp_number(isParamValid("_multiapp_number") ? _pars.get<unsigned int>("_multiapp_number")
                                                      : 0),
    _use_master_mesh(_pars.get<bool>("_use_master_mesh")),
    _master_mesh(isParamValid("_master_mesh") ? _pars.get<const MooseMesh *>("_master_mesh")
                                              : nullptr),
    _master_displaced_mesh(isParamValid("_master_displaced_mesh")
                               ? _pars.get<const MooseMesh *>("_master_displaced_mesh")
                               : nullptr),
    _mesh_generator_system(*this),
    _chain_control_system(*this),
    _rd_reader(*this, _restartable_data, forceRestart()),
    _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 MOOSE_LIBTORCH_ENABLED
    ,
    _libtorch_device(determineLibtorchDeviceType(getParam<MooseEnum>("libtorch_device")))
#endif
#ifdef MOOSE_MFEM_ENABLED
    ,
    _mfem_device(isParamValid("_mfem_device")
                     ? getParam<std::shared_ptr<mfem::Device>>("_mfem_device")
                     : nullptr),
    _mfem_devices(
        isParamValid("_mfem_devices")
            ? std::set<std::string>(getParam<std::vector<std::string>>("_mfem_devices").begin(),
                                    getParam<std::vector<std::string>>("_mfem_devices").end())
            : std::set<std::string>{})
#endif
{
  if (&parameters != &_pars)
  {
    const auto show_trace = Moose::show_trace;
    Moose::show_trace = false;
    const std::string bad_params = "(InputParameters parameters)";
    const std::string good_params = "(const InputParameters & parameters)";
    const std::string source_constructor = type() + "::" + type();
    mooseDoOnce(mooseDeprecated(type(),
                                " copy-constructs its input parameters.\n\n",
                                "This is deprecated and will not be allowed in the future.\n\n",
                                "In ",
                                type(),
                                ".C, change:\n  ",
                                source_constructor,
                                bad_params,
                                " -> ",
                                source_constructor,
                                good_params,
                                "\n\n",
                                "In ",
                                type(),
                                ".h, change:\n  ",
                                type(),
                                bad_params,
                                "; -> ",
                                type(),
                                good_params,
                                ";"));
    Moose::show_trace = show_trace;
  }

  // Set the TIMPI sync type via --timpi-sync
  const auto & timpi_sync = _pars.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 && isUltimateMaster())
    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");

#ifdef MOOSE_MFEM_ENABLED
  if (_mfem_device)
  {
    mooseAssert(!isUltimateMaster(),
                "The MFEM device should only be auto-set for sub-applications");
    mooseAssert(!_mfem_devices.empty(),
                "If we are a sub-application and we have an MFEM device object, then we must know "
                "its configuration string");
  }
#endif

  // 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 (_pars.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.");

  registerCapabilities();
  Moose::out << std::flush;
}

void
MooseApp::registerCapabilities()
{
  // helper lambdas
  auto haveCapability = [](const std::string & capability, const std::string & doc)
  { addCapability(capability, true, doc + " is available."); };

  auto missingCapability =
      [](const std::string & capability, const std::string & doc, const std::string & help = "")
  { addCapability(capability, false, doc + " is not available. " + help); };

  auto haveCapabilityVersion =
      [](const std::string & capability, const std::string & doc, const std::string & version)
  { addCapability(capability, version, doc + " version " + version + " is available."); };

  auto petscMissingCapability = [](const std::string & capability, const std::string & doc)
  {
    addCapability(
        capability, false, doc + " is not available. Check your PETSc configure options.");
  };

  auto libmeshMissingCapability =
      [](const std::string & capability, const std::string & doc, const std::string & config_option)
  {
    addCapability(capability,
                  false,
                  doc + " is not available. It is controlled by the `" + config_option +
                      "` libMesh configure option.");
  };

  // register capabilities
  if (_trap_fpe)
    addCapability("trap_fpe",
                  true,
                  "Trapping floating point exceptions is enabled (in debug mode this "
                  "can be disabled using the --no-trap-fpe option).");
  else
    addCapability("trap_fpe",
                  false,
                  "Trapping floating point exceptions is not enabled (enable them using "
                  "the --trap-fpe option or by running a debug mode executable).");

  {
    const auto doc = "LibTorch machine learning and parallel tensor algebra library";
#ifdef MOOSE_LIBTORCH_ENABLED
    addCapability("libtorch", TORCH_VERSION, doc);
#else
    missingCapability("libtorch",
                      doc,
                      "Check "
                      "https://mooseframework.inl.gov/moose/getting_started/installation/"
                      "install_libtorch.html for "
                      "instructions on how to configure and build moose with libTorch.");
#endif
  }

  {
    const auto doc = "MFEM finite element library";
#ifdef MOOSE_MFEM_ENABLED
    haveCapability("mfem", doc);
#else
    missingCapability("mfem",
                      doc,
                      "Install mfem using the scripts/update_and_rebuild_mfem.sh script after "
                      "first running scripts/update_and_rebuild_conduit.sh. Finally, configure "
                      "moose with ./configure --with-mfem");
#endif
  }

  {
    const auto doc = "New Engineering Material model Library, version 2";
#ifdef NEML2_ENABLED
    haveCapability("neml2", doc);
#else
    missingCapability("neml2",
                      doc,
                      "Install neml2 using the scripts/update_and_rebuild_neml2.sh script, then "
                      "configure moose with ./configure --with-neml2 --with-libtorch");
#endif
  }

  {
    const auto doc = "gperftools code performance analysis and profiling library";
#ifdef HAVE_GPERFTOOLS
    haveCapability("gperftools", doc);
#else
    missingCapability("gperftools",
                      doc,
                      "Check https://mooseframework.inl.gov/application_development/profiling.html "
                      "for instructions on profiling MOOSE based applications.");
#endif
  }

  {
    const auto doc = "libPNG portable network graphics format library";
#ifdef MOOSE_HAVE_LIBPNG
    haveCapability("libpng", doc);
#else
    missingCapability("libpng",
                      doc,
                      "Install libpng through conda or your distribution and check that it gets "
                      "detected through pkg-config, then reconfigure and rebuild MOOSE.");
#endif
  }

  {
    const auto doc = "NVIDIA GPU parallel computing platform";
#ifdef PETSC_HAVE_CUDA
    haveCapability("cuda", doc);
#else
    missingCapability("cuda", doc, "Add the CUDA bin directory to your path and rebuild PETSc.");
#endif
  }

  addCapability(
      "ad_size",
      MOOSE_AD_MAX_DOFS_PER_ELEM,
      "MOOSE was configured and built with a dual number backing store size of " +
          Moose::stringify(MOOSE_AD_MAX_DOFS_PER_ELEM) +
          ". Complex simulations with many variables or contact problems may require larger "
          "values. Reconfigure MOOSE with the --with-derivative-size=<n> option in the root of the "
          "repository.");
  {
    const std::string method = QUOTE(METHOD);
    addCapability("method", method, "The executable was built with METHOD=\"" + method + "\"");
  }

  {
    const std::string version = QUOTE(LIBMESH_DETECTED_PETSC_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_PETSC_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_PETSC_VERSION_SUBMINOR);
    addCapability("petsc", version, "Using PETSc version " + version + ".");
  }

#ifdef LIBMESH_PETSC_USE_DEBUG
  addCapability("petsc_debug", true, "PETSc was built with debugging options.");
#else
  addCapability("petsc_debug", false, "PETSc was built without debugging options.");
#endif

  {
    const auto doc = "SuperLU direct solver";
#ifdef LIBMESH_PETSC_HAVE_SUPERLU_DIST
    haveCapability("superlu", doc);
#else
    petscMissingCapability("superlu", doc);
#endif
  }

  {
    const auto doc = "MUltifrontal Massively Parallel sparse direct Solver (MUMPS)";
#ifdef LIBMESH_PETSC_HAVE_MUMPS
    haveCapability("mumps", doc);
#else
    petscMissingCapability("mumps", doc);
#endif
  }

  {
    const auto doc = "STRUMPACK - STRUctured Matrix PACKage solver library";
#ifdef LIBMESH_PETSC_HAVE_STRUMPACK
    haveCapability("strumpack", doc);
#else
    petscMissingCapability("strumpack", doc);
#endif
  }

  {
    const auto doc = "Parmetis partitioning library";
#if defined(LIBMESH_PETSC_HAVE_PARMETIS) || defined(LIBMESH_HAVE_PARMETIS)
    haveCapability("parmetis", doc);
#else
    petscMissingCapability("parmetis", doc);
#endif
  }

  {
    const auto doc = "Chaco graph partitioning library";
#ifdef LIBMESH_PETSC_HAVE_CHACO
    haveCapability("chaco", doc);
#else
    petscMissingCapability("chaco", doc);
#endif
  }

  {
    const auto doc = "Party matrix or graph partitioning library";
#ifdef LIBMESH_PETSC_HAVE_PARTY
    haveCapability("party", doc);
#else
    petscMissingCapability("party", doc);
#endif
  }

  {
    const auto doc = "PT-Scotch graph partitioning library";
#ifdef LIBMESH_PETSC_HAVE_PTSCOTCH
    haveCapability("ptscotch", doc);
#else
    petscMissingCapability("ptscotch", doc);
#endif
  }

  {
    const auto doc = "Scalable Library for Eigenvalue Problem Computations (SLEPc)";
#ifdef LIBMESH_HAVE_SLEPC
    const auto version = QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_SLEPC_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_SUBMINOR);
    haveCapabilityVersion("slepc", doc, version);
#else
    petscMissingCapability("slepc", doc);
#endif
  }

  {
    const auto doc = "Exodus mesh file format library";
#ifdef LIBMESH_HAVE_EXODUS_API
    const std::string version = QUOTE(LIBMESH_DETECTED_EXODUS_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_EXODUS_VERSION_MINOR);
    haveCapabilityVersion("exodus", doc, version);
#else
    libmeshMissingCapability("exodus", doc, "--enable-exodus");
#endif
  }

  {
    const auto doc = "Netgen meshing library";
#ifdef LIBMESH_HAVE_NETGEN
    haveCapability("netgen", doc);
#else
    libmeshMissingCapability("netgen", doc, "--enable-netgen");
#endif
  }

  {
    const auto doc = "Visualization Toolkit (VTK)";
#ifdef LIBMESH_HAVE_VTK
    const std::string version = QUOTE(LIBMESH_DETECTED_VTK_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_VTK_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_VTK_VERSION_SUBMINOR);
    haveCapabilityVersion("vtk", doc, version);
#else
    libmeshMissingCapability("vtk", doc, "--disable-vtk and --enable-vtk-required");
#endif
  }

  {
    const auto doc = "libcurl - the multiprotocol file transfer library";
#ifdef LIBMESH_HAVE_CURL
    haveCapability("curl", doc);
#else
    libmeshMissingCapability("curl", doc, "--enable-curl");
#endif
  }

  {
    const auto doc = "Tecplot post-processing tools API";
#ifdef LIBMESH_HAVE_TECPLOT_API
    haveCapability("tecplot", doc);
#else
    libmeshMissingCapability("tecplot", doc, "--enable-tecplot");
#endif
  }

  {
    const auto doc = "Boost C++ library";
#ifdef LIBMESH_HAVE_EXTERNAL_BOOST
    haveCapability("boost", doc);
#else
    libmeshMissingCapability("boost", doc, "--with-boost");
#endif
  }

  // libmesh stuff
  {
    const auto doc = "Adaptive mesh refinement";
#ifdef LIBMESH_ENABLE_AMR
    haveCapability("amr", doc);
#else
    libmeshMissingCapability("amr", doc, "--disable-amr");
#endif
  }

  {
    const auto doc = "nanoflann library for Nearest Neighbor (NN) search with KD-trees";
#ifdef LIBMESH_HAVE_NANOFLANN
    haveCapability("nanoflann", doc);
#else
    libmeshMissingCapability("nanoflann", doc, "--disable-nanoflann");
#endif
  }

#ifdef LIBMESH_HAVE_FPARSER
#ifdef LIBMESH_HAVE_FPARSER_JIT
  addCapability("fparser", "jit", "FParser enabled with just in time compilation support.");
#else
  addCapability("fparser", "byte_code", "FParser enabled.");
#endif
#else
  addCapability("fparser",
                false,
                "FParser is disabled, libMesh was likely configured with --disable-fparser.");
#endif

#ifdef LIBMESH_HAVE_DLOPEN
  addCapability(
      "dlopen", true, "The dlopen() system call is available to dynamically load libraries.");
#else
  addCapability("dlopen",
                false,
                "The dlopen() system call is not available. Dynamic library loading is "
                "not supported on this system.");
#endif

  {
    const auto doc = "LibMesh support for threaded execution";
#ifdef LIBMESH_USING_THREADS
    haveCapability("threads", doc);
#else
    libmeshMissingCapability("threads", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }

  {
    const auto doc = "OpenMP multi-platform shared-memory parallel programming API";
#ifdef LIBMESH_HAVE_OPENMP
    haveCapability("openmp", doc);
#else
    libmeshMissingCapability("openmp", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }
  {
    const auto doc = "oneAPI Threading Building Blocks (TBB) API";
#ifdef LIBMESH_HAVE_TBB_API
    haveCapability("tbb", doc);
#else
    libmeshMissingCapability("tbb", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }

  {
    const auto doc = "libMesh unique ID support";
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    haveCapability("unique_id", doc);
#else
    libmeshMissingCapability("unique_id", doc, "--enable-unique-id");
#endif
  }

  {
    const auto doc = "libMesh default mesh mode";
#ifdef LIBMESH_ENABLE_PARMESH
    addCapability("mesh_mode", "distributed", doc);
#else
    addCapability("mesh_mode", "replicated", doc);
#endif
  }

  addCapability("dof_id_bytes",
                static_cast<int>(sizeof(dof_id_type)),
                "Degree of freedom (DOF) identifiers use " + Moose::stringify(sizeof(dof_id_type)) +
                    " bytes for storage. This is controlled by the "
                    "--with-dof-id-bytes=<1|2|4|8> libMesh configure option.");

  // compiler
  {
    const auto doc = "Compiler used to build the MOOSE framework.";
#if defined(__clang__)
    addCapability("compiler", "clang", doc);
#elif defined(__GNUC__) || defined(__GNUG__)
    addCapability("compiler", "gcc", doc);
#elif defined(_MSC_VER)
    addCapability("compiler", "msvc", doc);
#else
    addCapability("compiler", false, "Unknown compiler");
#endif
  }

  // OS related
  {
    const auto doc = "Operating system this executable is running on.";
#ifdef __APPLE__
    addCapability("platform", "darwin", doc);
#elif __WIN32__
    addCapability("platform", "win32", doc);
#elif __linux__
    addCapability("platform", "linux", doc);
#elif __unix__ // all unices not caught above
    addCapability("platform", "unix", doc);
#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 237 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(), JSONOutput::outputReporters(), PostprocessorInterface::postprocessorsAdded(), ReporterInterface::reportersAdded(), MeshGenerator::setMeshProperty(), PetscOutput::solveSetup(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

{ return _action_warehouse; }

actionWarehouse() [2/2]

const ActionWarehouse& MooseApp::actionWarehouse ( ) const

inline

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

Definition at line 241 of file MooseApp.h.

{ return _action_warehouse; }

addAppParam()

void MooseApp::addAppParam ( InputParameters &  params )

static

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

addCapability() [1/2]

void MooseApp::addCapability ( const std::string &  capability, CapabilityUtils::Type  value, const std::string &  doc  )

staticprotected

register a new capability

Definition at line 3556 of file MooseApp.C.

{
  Moose::Capabilities::getCapabilityRegistry().add(capability, value, doc);
}

addCapability() [2/2]

void MooseApp::addCapability ( const std::string &  capability, const char *  value, const std::string &  doc  )

staticprotected

Definition at line 3564 of file MooseApp.C.

{
  Moose::Capabilities::getCapabilityRegistry().add(capability, std::string(value), doc);
}

addExecutor()

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

Definition at line 1961 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 1973 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 101 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 873 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 2989 of file MooseApp.C.

Referenced by AdaptivityAction::act(), SetAdaptivityOptionsAction::act(), AddPeriodicBCAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), 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 137 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 924 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 2419 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 3202 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 1842 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 1853 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 246 of file MooseApp.h.

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

{ return _builder; }

callMooseError()

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

inherited

Calls moose error with the message msg.

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

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

Definition at line 33 of file MooseBase.C.

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

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

checkInput()

bool MooseApp::checkInput ( ) const

inline

Returns whether the Application is running in check input mode.

Definition at line 947 of file MooseApp.h.

{ return _check_input; }

checkMetaDataIntegrity()

void MooseApp::checkMetaDataIntegrity

(

)

const

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

Definition at line 3393 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 3037 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::outputExecutionInformation(), ConsoleUtils::outputFrameworkInformation(), and MooseServer::parseDocumentForDiagnostics().

{ return _command_line; }

constructingMeshGenerators()

bool MooseApp::constructingMeshGenerators ( ) const

virtual

Whether this app is constructing mesh generators.

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

Definition at line 3492 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 2222 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 2040 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 2889 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 3461 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 3479 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 3133 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 1026 of file MooseApp.h.

{ return _automatic_automatic_scaling; }

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 3500 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 1948 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 2636 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 2579 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 2665 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 1727 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 1060 of file MooseApp.h.

{ return false; }

errorPrefix()

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

inherited

Returns

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

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::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 1763 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();
    if (!_executioner->lastSolveConverged())
      setExitCode(1);
  }
  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 150 of file MooseApp.h.

Referenced by copyInputs().

{ return _exit_code; }

feProblem()

FEProblemBase & MooseApp::feProblem

(

)

const

Definition at line 1954 of file MooseApp.C.

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

{
  mooseAssert(_executor.get() || _executioner.get(), "No executioner yet, calling too early!");
  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 1910 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().

{ return _fixed_point_config; }

forceRestart()

bool MooseApp::forceRestart ( ) const

inline

Whether or not we are forcefully restarting (allowing the load of potentially incompatibie checkpoints); used within RestartableDataReader.

Definition at line 1085 of file MooseApp.h.

Referenced by possiblyLoadRestartableMetaData().

{ return _force_restart; }

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

{ return _action_factory; }

getChainControlDataSystem()

ChainControlDataSystem& MooseApp::getChainControlDataSystem ( )

inline

Gets the system that manages the ChainControls.

Definition at line 862 of file MooseApp.h.

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

{ return _chain_control_system; }

getCheckpointDirectories()

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

(

)

const

Get all checkpoint directories.

Returns

A Set of checkpoint directories

Definition at line 2355 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 2387 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 1029 of file MooseApp.h.

Referenced by MooseServer::parseDocumentForDiagnostics().

{ return _comm; }

getCurrentActionHitNode()

const hit::Node * MooseApp::getCurrentActionHitNode

(

)

const

Returns

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

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

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

{ return _distributed_mesh_on_command_line; }

getExecuteOnEnum()

const ExecFlagEnum& MooseApp::getExecuteOnEnum ( ) const

inline

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

Definition at line 1011 of file MooseApp.h.

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

{ return _execute_flags; }

getExecutioner()

Executioner * MooseApp::getExecutioner

(

)

const

Retrieve the Executioner for this App.

Definition at line 2111 of file MooseApp.C.

Referenced by CheckIntegrityAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), AddTimeStepperAction::act(), ComposeTimeStepperAction::act(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), LazyCoupleable::coupled(), EigenProblem::doFreeNonlinearPowerIterations(), EigenKernel::EigenKernel(), PseudoTimestep::execute(), IterationInfo::execute(), PIDTransientControl::execute(), Terminator::execute(), ChangeOverFixedPointPostprocessor::finalize(), FVAdvection::FVAdvection(), DefaultConvergenceBase::getSharedExecutionerParam(), NumFixedPointIterations::getValue(), FEProblemBase::init(), Console::initialSetup(), MFEMProblem::initProblemOperator(), 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 361 of file MooseApp.h.

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

{ return _executor.get(); }

getExecutor() [2/2]

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

Get an Executor.

Parameters

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

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

{ return _initial_from_file; }

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

{ return _ex_reader.get(); }

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(), AStableDirk4::AStableDirk4(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), SingleRankPartitioner::clone(), CopyMeshPartitioner::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(), SampledOutput::cloneMesh(), MeshGeneratorSystem::createMeshGenerator(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OverlayMeshGenerator::OverlayMeshGenerator(), TiledMesh::safeClone(), FileMesh::safeClone(), ImageMesh::safeClone(), GeneratedMesh::safeClone(), SpiralAnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), AnnularMesh::safeClone(), RinglebMesh::safeClone(), MeshGeneratorMesh::safeClone(), StitchedMesh::safeClone(), PatternedMesh::safeClone(), MFEMMesh::safeClone(), TransientBase::setupTimeIntegrator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

{ return _factory; }

getFileName()

std::string MooseApp::getFileName

(

bool

stripLeadingPath = true

)

const

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

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

{ return _trap_fpe; }

getFrameworkVersion()

std::string MooseApp::getFrameworkVersion

(

)

const

Returns the framework version.

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

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

{ return _global_time_offset; }

getInputFileNames()

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

(

)

const

Returns

the input file names set in the Parser

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

Referenced by FEProblemBase::addMaterialHelper(), MooseBaseParameterInterface::connectControllableParams(), ActionFactory::create(), Factory::initialize(), NEML2Action::NEML2Action(), 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 2216 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 1666 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 1656 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 2839 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 104 of file MooseApp.h.

{ return _libtorch_device; }

getLoadedLibraryPaths()

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

(

)

const

Return the paths of loaded libraries.

Definition at line 2828 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 891 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 899 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 909 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 857 of file MooseApp.h.

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

{ return _mesh_generator_system; }

getMFEMDevice()

std::shared_ptr<mfem::Device> MooseApp::getMFEMDevice ( Moose::PassKey< MultiApp >  )

inline

Get the MFEM device object.

Definition at line 1103 of file MooseApp.h.

Referenced by MultiApp::createApp().

{ return _mfem_device; }

getMFEMDevices()

const std::set< std::string > & MooseApp::getMFEMDevices ( Moose::PassKey< MultiApp >  ) const

inline

Get the configured MFEM devices.

Definition at line 1679 of file MooseApp.h.

Referenced by MultiApp::createApp().

{
  return _mfem_devices;
}

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

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

{ return _app; }

getNullExecutor()

NullExecutor* MooseApp::getNullExecutor ( ) const

inline

Definition at line 362 of file MooseApp.h.

Referenced by ExecutorInterface::getExecutor().

{ return _null_executor.get(); }

getOutputFileBase()

std::string MooseApp::getOutputFileBase

(

bool

for_non_moose_build_output = false

)

const

Get the output file base name.

Parameters

for_non_moose_build_output

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

Returns

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

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

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

{ return _output_position; }

getOutputWarehouse() [1/2]

OutputWarehouse & MooseApp::getOutputWarehouse

(

)

Get the OutputWarehouse objects.

Definition at line 2407 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 2413 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 1605 of file MooseApp.h.

Referenced by CommonOutputAction::act(), FEProblemBase::addOutput(), Console::Console(), 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 1612 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 135 of file MooseApp.h.

Referenced by getPrintableVersion().

{ return "Application"; }

getPrintableVersion()

std::string MooseApp::getPrintableVersion

(

)

const

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

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

{ return _recoverable_data_names; }

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

{ return _restartable_data; }

getRestartableData() [2/2]

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

inline

Definition at line 705 of file MooseApp.h.

{ return _restartable_data; }

getRestartableDataMap()

RestartableDataMap & MooseApp::getRestartableDataMap

(

const RestartableDataMapName &

name

)

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

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

Referenced by SetupDebugAction::act().

{ return _restartable_meta_data.begin(); }

getRestartableDataMapEnd()

auto MooseApp::getRestartableDataMapEnd ( )

inline

Definition at line 1052 of file MooseApp.h.

Referenced by SetupDebugAction::act().

{ return _restartable_meta_data.end(); }

getRestartableDataMapName()

const std::string & MooseApp::getRestartableDataMapName

(

const RestartableDataMapName &

name

)

const

Returns

The output name for the restartable data with name name

Definition at line 3452 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 2509 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().

{ return _restart_recover_base; }

getRMClone()

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

private

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

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

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

{ return _start_time; }

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(), and to_json().

{ return _sys_info.get(); }

getVersion()

std::string MooseApp::getVersion ( ) const

virtual

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

Definition at line 1210 of file MooseApp.C.

Referenced by getPrintableVersion().

{
  return MOOSE_VERSION;
}

hasInitialBackup()

bool MooseApp::hasInitialBackup ( ) const

inline

Returns

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

See _initial_backup and restoreFromInitialBackup() for more info.

Definition at line 1018 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 883 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 302 of file MooseApp.h.

Referenced by Exodus::output().

{ return _output_position_set; }

hasRecoverFileBase()

bool MooseApp::hasRecoverFileBase

(

)

const

Definition at line 1819 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 2963 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 3436 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 2499 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 1813 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 3068 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 321 of file MooseApp.h.

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

{ return _start_time_set; }

header()

std::string MooseApp::header ( ) const

virtual

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

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

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

{ return _pars.isParamSetByUser(nm); }

isParamValid()

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

inline

Definition at line 205 of file MooseApp.h.

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

{ return _pars.isParamValid(name); }

isRecovering()

bool MooseApp::isRecovering

(

)

const

Whether or not this is a "recover" calculation.

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

Definition at line 1795 of file MooseApp.C.

Referenced by ExecuteMeshGenerators::act(), SetupMeshCompleteAction::act(), SetupMeshAction::act(), SetupRecoverFileBaseAction::act(), SampledOutput::cloneMesh(), MultiApp::createApp(), InversePowerMethod::execute(), NonlinearEigen::execute(), MFEMSteady::execute(), PIDTransientControl::execute(), SteadyBase::execute(), Eigenvalue::execute(), FullSolveMultiApp::FullSolveMultiApp(), NonlinearEigen::init(), InversePowerMethod::init(), TransientBase::init(), MooseMesh::init(), Console::initialSetup(), FEProblemBase::initialSetup(), SampledOutput::outputStep(), Output::outputStep(), TransientBase::preExecute(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), PhysicsBase::shouldCreateIC(), 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 1801 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(), PhysicsBase::shouldCreateIC(), and TransientMultiApp::solveStep().

{
  return _restart;
}

isSplitMesh()

bool MooseApp::isSplitMesh

(

)

const

Whether or not this is a split mesh operation.

Definition at line 1807 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::checkProblemIntegrity(), CopyMeshPartitioner::CopyMeshPartitioner(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), FixedPointSolve::FixedPointSolve(), MooseMesh::init(), FEProblemBase::initialSetup(), Eigenvalue::prepareSolverOptions(), PerfGraphLivePrint::printStats(), setupOptions(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::~FEProblemBase().

{ return !_multiapp_level; }

libNameToAppName()

std::string MooseApp::libNameToAppName

(

const std::string &

library_name

)

const

Converts a library name to an application name:

Definition at line 2435 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 2678 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 2543 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 852 of file MooseApp.h.

Referenced by SetupMeshAction::act().

{ return _master_displaced_mesh; }

masterMesh()

const MooseMesh* MooseApp::masterMesh ( ) const

inline

Returns a pointer to the master mesh.

Definition at line 847 of file MooseApp.h.

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

{ return _master_mesh; }

metaDataFolderBase()

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

static

The file suffix for meta data (header and data)

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

{ return _multiapp_level; }

multiAppNumber()

unsigned int MooseApp::multiAppNumber ( ) const

inline

The MultiApp number.

Returns

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

Definition at line 832 of file MooseApp.h.

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

{ return _multiapp_number; }

name()

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

inlinevirtualinherited

Get the name of the class.

Returns

The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

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

{ return _name; }

outputMachineReadableData()

void MooseApp::outputMachineReadableData ( const std::string &  param, const std::string &  start_marker, const std::string &  end_marker, const std::string &  data  ) const

protected

Outputs machine readable data (JSON, YAML, etc.) either to the screen (if no filename was provided as an argument to the parameter param) or to a file (if a filename was provided).

Definition at line 3529 of file MooseApp.C.

Referenced by runInputFile(), and setupOptions().

{
  // Bool parameter, just to screen
  if (_pars.have_parameter<bool>(param))
  {
    Moose::out << start_marker << data << end_marker << std::endl;
    return;
  }

  // String parameter, to file
  const auto & filename = getParam<std::string>(param);
  // write to file
  std::ofstream out(filename.c_str());
  if (out.is_open())
  {
    std::ofstream out(filename.c_str());
    out << data << std::flush;
    out.close();
  }
  else
    mooseError("Unable to open file `", filename, "` for writing ", param, " data to it.");
}

parameters()

const InputParameters& MooseApp::parameters ( )

inline

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 161 of file MooseApp.h.

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

{ return _pars; }

parser()

Parser & MooseApp::parser

(

)

Returns

The Parser

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

Referenced by PerfGraphInterface::perfGraph().

{ return _perf_graph; }

possiblyLoadRestartableMetaData()

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

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

Definition at line 2528 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), forceRestart());
    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().

{}

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

{}

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 restartFolderBase(), FileOutput::setFileBaseInternal(), and writeRestartableMetaData().

{ return _comm->rank(); }

rankMap()

const RankMap& MooseApp::rankMap ( )

inline

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

Definition at line 167 of file MooseApp.h.

{ return _rank_map; }

recursivelyCreateExecutors()

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

private

Internal function used to recursively create the executor objects.

Called by createExecutors

Parameters

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

Definition at line 1988 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();
}

registerCapabilities()

void MooseApp::registerCapabilities ( )

private

Register all base MooseApp capabilities to the Moose::Capabilities registry.

Apps and Modules may register additional capabilities in their registerAll function.

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 1644 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 2447 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 3442 of file MooseApp.C.

{
  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 1827 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 1034 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 3091 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 3052 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 1868 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 1881 of file MooseApp.C.

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

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

  if (!backup)
    mooseError("MooseApp::restore(): 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 1903 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 2123 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 1688 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 (isParamSetByUser("parse_neml2_only"))
  {
    _early_exit_param = "--parse-neml2-only";
    _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::stringstream ss;
    for (const auto & obj : _factory.getConstructedObjects())
      ss << obj << '\n';
    outputMachineReadableData(
        "list_constructed_objects", "**START OBJECT DATA**\n", "\n**END OBJECT DATA**", ss.str());
  }
}

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 2287 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 1942 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 2117 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 369 of file MooseApp.h.

Referenced by CreateExecutionerAction::act().

{ _executioner = executioner; }

setExecutor()

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

inline

Definition at line 370 of file MooseApp.h.

{ _executor = executor; }

setExitCode()

void MooseApp::setExitCode ( const int  exit_code )

inline

Sets the exit code that the application will exit with.

Definition at line 155 of file MooseApp.h.

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

{ _exit_code = exit_code; }

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

{ _initial_from_file = flag; }

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

{ _global_time_offset = offset; }

setMFEMDevice()

void MooseApp::setMFEMDevice	(	const std::string &	device_string,
		Moose::PassKey< MFEMExecutioner >
	)

Create/configure the MFEM device with the provided device_string.

More than one device can be configured. If supplying multiple devices, they should be comma separated

Definition at line 3571 of file MooseApp.C.

Referenced by MFEMExecutioner::MFEMExecutioner().

{
  const auto string_vec = MooseUtils::split(device_string, ",");
  auto string_set = std::set<std::string>(string_vec.begin(), string_vec.end());
  if (!_mfem_device)
  {
    _mfem_device = std::make_shared<mfem::Device>(device_string);
    _mfem_devices = std::move(string_set);
    _mfem_device->Print(Moose::out);
  }
  else if (string_set != _mfem_devices)
    mooseError("Attempted to configure with MFEM devices '",
               MooseUtils::join(string_set, " "),
               "', but we have already configured the MFEM device object with the devices '",
               MooseUtils::join(_mfem_devices, " "),
               "'");
}

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 1672 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 2344 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 2883 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 2877 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 2394 of file MooseApp.C.

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

{
  _start_time_set = true;
  _start_time = time;
}

setupOptions()

void MooseApp::setupOptions ( )

virtual

Setup options based on InputParameters.

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

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

    outputMachineReadableData(
        "json", "**START JSON DATA**\n", "\n**END JSON DATA**", tree.getRoot().dump(2));
    _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();
    std::stringstream ss;
    for (const auto & it : syntax)
      ss << it.first << "\n";
    outputMachineReadableData("syntax", "**START SYNTAX DATA**\n", "**END SYNTAX DATA**", ss.str());
    _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 (getParam<bool>("show_capabilities"))
  {
    _perf_graph.disableLivePrint();
    outputMachineReadableData("show_capabilities",
                              "**START JSON DATA**\n",
                              "\n**END JSON DATA**",
                              Moose::Capabilities::getCapabilityRegistry().dump());
    _ready_to_exit = true;
  }
  else if (isParamValid("check_capabilities"))
  {
    _perf_graph.disableLivePrint();
    const auto & capabilities = getParam<std::string>("check_capabilities");
    auto [status, reason, doc] = Moose::Capabilities::getCapabilityRegistry().check(capabilities);
    const bool pass = status == CapabilityUtils::CERTAIN_PASS;
    _console << "Capabilities '" << capabilities << "' are " << (pass ? "" : "not ") << "fulfilled."
             << std::endl;
    _ready_to_exit = true;
    if (!pass)
      _exit_code = 77;
    return;
  }
  else if (!getInputFileNames().empty())
  {
    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 (isParamValid("required_capabilities"))
    {
      _perf_graph.disableLivePrint();

      const auto required_capabilities = getParam<std::string>("required_capabilities");
      auto [status, reason, doc] =
          Moose::Capabilities::getCapabilityRegistry().check(required_capabilities);
      if (status < CapabilityUtils::UNKNOWN)
      {
        mooseInfo("Required capabilities '", required_capabilities, "' not fulfilled.");
        _ready_to_exit = true;
        // we use code 77 as "skip" in the Testharness
        _exit_code = 77;
        return;
      }
      if (status == CapabilityUtils::UNKNOWN)
        mooseError("Required capabilities '",
                   required_capabilities,
                   "' are not specific enough. A comparison test is performed on an undefined "
                   "capability. Disambiguate this requirement by adding an existence/non-existence "
                   "requirement. Example: 'unknown<1.2.3' should become 'unknown & unknown<1.2.3' "
                   "or '!unknown | unknown<1.2.3'");
    }

    // Lambda to check for mutually exclusive parameters
    auto isExclusiveParamSetByUser =
        [this](const std::vector<std::string> & group, const std::string & param)
    {
      auto is_set = isParamSetByUser(param);
      if (is_set)
        for (const auto & p : group)
          if (p != param && isParamSetByUser(p))
            mooseError("Parameters '" + p + "' and '" + param +
                       "' are mutually exclusive. Please choose only one of them.");
      return is_set;
    };

    // The following parameters set the final task and so are mutually exclusive.
    const std::vector<std::string> final_task_params = {
        "mesh_only", "split_mesh", "parse_neml2_only"};
    if (isExclusiveParamSetByUser(final_task_params, "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 (isExclusiveParamSetByUser(final_task_params, "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");
    }
    else if (isExclusiveParamSetByUser(final_task_params, "parse_neml2_only"))
    {
      _syntax.registerTaskName("parse_neml2");
      _syntax.addDependency("determine_system_type", "parse_neml2");
      _action_warehouse.setFinalTask("parse_neml2");
    }
    _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 2184 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 178 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().

{ return _solution_invalidity; }

solutionInvalidity() [2/2]

const SolutionInvalidity& MooseApp::solutionInvalidity ( ) const

inline

Definition at line 179 of file MooseApp.h.

{ return _solution_invalidity; }

syntax()

Syntax& MooseApp::syntax ( )

inline

Returns a writable reference to the syntax object.

Definition at line 251 of file MooseApp.h.

Referenced by dynamicAllRegistration(), and setupOptions().

{ return _syntax; }

testCheckpointHalfTransient()

bool MooseApp::testCheckpointHalfTransient ( ) const

inline

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

Definition at line 541 of file MooseApp.h.

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

{ return _test_checkpoint_half_transient; }

theWarehouse()

TheWarehouse& MooseApp::theWarehouse ( )

inline

Definition at line 130 of file MooseApp.h.

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

{ return *_the_warehouse; }

timedSectionName()

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

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

type()

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

inlineinherited

Get the type of this class.

Returns

the name of the type of this class

Definition at line 51 of file MooseBase.h.

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

{ return _type; }

typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

Returns

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

Definition at line 27 of file MooseBase.C.

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

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

unusedFlagIsError()

bool MooseApp::unusedFlagIsError ( ) const

inline

Returns whether the flag for unused parameters is set to throw an error.

Definition at line 1091 of file MooseApp.h.

Referenced by MeshOnlyAction::act(), and PhysicsBase::reportPotentiallyMissedParameters().

{ return _enable_unused_check == ERROR_UNUSED; }

unusedFlagIsWarning()

bool MooseApp::unusedFlagIsWarning ( ) const

inline

Returns whether the flag for unused parameters is set to throw a warning only.

Definition at line 1088 of file MooseApp.h.

Referenced by MeshOnlyAction::act(), and PhysicsBase::reportPotentiallyMissedParameters().

{ return _enable_unused_check == WARN_UNUSED; }

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

{ return _use_eigen_value; }

useExecutor()

bool MooseApp::useExecutor ( ) const

inline

Definition at line 363 of file MooseApp.h.

{ return _use_executor; }

useMasterMesh()

bool MooseApp::useMasterMesh ( ) const

inline

Returns whether to use the parent app mesh as the mesh for this app.

Definition at line 842 of file MooseApp.h.

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

{ return _use_master_mesh; }

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

{ return _use_nonlinear; }

validParams()

InputParameters MooseApp::validParams ( )

static

Definition at line 108 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>(
      "show_capabilities", "--show-capabilities", "Dumps the capability registry in JSON format.");
  params.addCommandLineParam<std::string>(
      "required_capabilities",
      "--required-capabilities",
      "A list of conditions that is checked against the registered capabilities (see "
      "--show-capabilities). The executable will terminate early if the conditions are not met.");
  params.addCommandLineParam<std::string>(
      "check_capabilities",
      "--check-capabilities",
      "A list of conditions that is checked against the registered capabilities. Will exit based "
      "on whether or not the capaiblities are fulfilled. Does not check dynamically loaded apps.");
  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>(
      "force_restart",
      "--force-restart",
      "Forcefully load checkpoints despite possible incompatibilities");
  params.setGlobalCommandLineParam("force_restart");

  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<bool>("_use_master_mesh", false);
  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");
#ifdef MOOSE_MFEM_ENABLED
  params.addPrivateParam<std::shared_ptr<mfem::Device>>("_mfem_device");
  params.addPrivateParam<std::vector<std::string>>("_mfem_devices");
#endif

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

  params.addCommandLineParam<bool>(
      "parse_neml2_only",
      "--parse-neml2-only",
      "Executes the [NEML2] block to parse the input file and terminate.");

  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 2550 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 2564 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 1598 of file MooseApp.h.

Restartable

friend class Restartable

friend

Definition at line 1599 of file MooseApp.h.

SubProblem

friend class SubProblem

friend

Definition at line 1600 of file MooseApp.h.

Member Data Documentation

_action_factory

ActionFactory MooseApp::_action_factory

protected

The Factory responsible for building Actions.

Definition at line 1203 of file MooseApp.h.

Referenced by createMinimalApp(), and getActionFactory().

_action_warehouse

ActionWarehouse MooseApp::_action_warehouse

protected

Where built actions are stored.

Definition at line 1206 of file MooseApp.h.

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

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), ElementIDOutputAction::act(), CopyNodalVarsAction::act(), CreateExecutionerAction::act(), DeclareLateReportersAction::act(), AddExecutorAction::act(), AutoCheckpointAction::act(), ExecuteMeshGenerators::act(), AddMeshGeneratorAction::act(), ReadExecutorParamsAction::act(), CheckIntegrityAction::act(), SetupMeshCompleteAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), AdaptivityAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), CombineComponentsMeshes::act(), SplitMeshAction::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(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), BatchMeshGeneratorAction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addMultiApp(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), 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(), FEProblemBase::checkProblemIntegrity(), CheckOutputAction::checkVariableOutput(), SingleRankPartitioner::clone(), CopyMeshPartitioner::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(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), CopyMeshPartitioner::CopyMeshPartitioner(), 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(), MFEMSteady::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(), FileMeshGenerator::generate(), ExtraNodesetGenerator::generate(), SideSetsFromNormalsGenerator::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(), MFEMProblem::initProblemOperator(), MeshGenerator::MeshGenerator(), MFEMExecutioner::MFEMExecutioner(), MFEMTransient::MFEMTransient(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NEML2Action::NEML2Action(), 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(), JSONOutput::outputReporters(), SampledOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), JSONOutput::outputSystemInformation(), Console::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), PhysicsBase::prepareCopyVariablesFromMesh(), Eigenvalue::prepareSolverOptions(), NEML2Action::printSummary(), FEProblemBase::projectSolution(), PhysicsBase::reportPotentiallyMissedParameters(), TiledMesh::safeClone(), FileMesh::safeClone(), ImageMesh::safeClone(), GeneratedMesh::safeClone(), ConcentricCircleMesh::safeClone(), AnnularMesh::safeClone(), SpiralAnnularMesh::safeClone(), RinglebMesh::safeClone(), MeshGeneratorMesh::safeClone(), StitchedMesh::safeClone(), PatternedMesh::safeClone(), MFEMMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), MeshGeneratorComponent::setupComponent(), SetupMeshAction::setupMesh(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), PhysicsBase::shouldCreateIC(), 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 1331 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 1561 of file MooseApp.h.

Referenced by defaultAutomaticScaling().

_builder

Moose::Builder MooseApp::_builder

protected

Builder for building app related parser tree.

Definition at line 1215 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 1544 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 1324 of file MooseApp.h.

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

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

_command_line

std::shared_ptr<CommandLine> MooseApp::_command_line

protected

Command line object.

Definition at line 1193 of file MooseApp.h.

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

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

_cpu_profiling

bool MooseApp::_cpu_profiling = false

private

CPU profiling.

Definition at line 1564 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 1294 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 1282 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(), setCheckUnusedFlag(), unusedFlagIsError(), and unusedFlagIsWarning().

_error_overridden

bool MooseApp::_error_overridden

protected

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

Definition at line 1280 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 1291 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 1555 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 1236 of file MooseApp.h.

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

_executor

std::shared_ptr<Executor> MooseApp::_executor

protected

Pointer to the Executor of this run.

Definition at line 1239 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 1247 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 1242 of file MooseApp.h.

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

_exit_code

int MooseApp::_exit_code

protected

The exit code.

Definition at line 1285 of file MooseApp.h.

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

_factory

Factory MooseApp::_factory

protected

Definition at line 1277 of file MooseApp.h.

Referenced by addExecutor(), createExecutors(), getFactory(), 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 1175 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 1251 of file MooseApp.h.

Referenced by fixedPointConfig().

_force_restart

const bool MooseApp::_force_restart

protected

Whether or not we are forcefully attempting to load checkpoints (–force-restart)

Definition at line 1309 of file MooseApp.h.

Referenced by forceRestart().

_global_time_offset

Real MooseApp::_global_time_offset

protected

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

Definition at line 1190 of file MooseApp.h.

Referenced by getGlobalTimeOffset(), and setGlobalTimeOffset().

_heap_profiling

bool MooseApp::_heap_profiling = false

private

Memory profiling.

Definition at line 1567 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 1582 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 1288 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 1200 of file MooseApp.h.

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

_interface_registry

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

private

Registration for interface objects.

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

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

_libtorch_device

const torch::DeviceType MooseApp::_libtorch_device

private

The libtorch device this app is using.

Definition at line 1586 of file MooseApp.h.

_master_displaced_mesh

const MooseMesh* const MooseApp::_master_displaced_mesh

private

The displaced mesh from master app.

Definition at line 1538 of file MooseApp.h.

Referenced by masterDisplacedMesh().

_master_mesh

const MooseMesh* const MooseApp::_master_mesh

private

The mesh from master app.

Definition at line 1535 of file MooseApp.h.

Referenced by masterMesh().

_mesh_generator_system

MeshGeneratorSystem MooseApp::_mesh_generator_system

private

The system that manages the MeshGenerators.

Definition at line 1541 of file MooseApp.h.

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

_mfem_device

std::shared_ptr<mfem::Device> MooseApp::_mfem_device

private

The MFEM Device object.

Definition at line 1591 of file MooseApp.h.

Referenced by getMFEMDevice(), and setMFEMDevice().

_mfem_devices

std::set<std::string> MooseApp::_mfem_devices

private

MFEM supported devices based on user-provided config.

Definition at line 1594 of file MooseApp.h.

Referenced by getMFEMDevices(), and setMFEMDevice().

_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 1526 of file MooseApp.h.

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

_multiapp_number

unsigned int MooseApp::_multiapp_number

private

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

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

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

_null_executor

std::shared_ptr<NullExecutor> MooseApp::_null_executor

protected

Used to return an executor that does nothing.

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

Referenced by setupOptions().

_output_file_base

std::string MooseApp::_output_file_base

protected

The output file basename.

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

Referenced by getOutputFileNumbers(), and setOutputFileNumbers().

_output_position

Point MooseApp::_output_position

protected

The output position.

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

Referenced by hasOutputPosition(), and setOutputPosition().

_output_warehouse

OutputWarehouse MooseApp::_output_warehouse

protected

OutputWarehouse object for this App.

Definition at line 1209 of file MooseApp.h.

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

_pars

const InputParameters& MooseApp::_pars

protected

Parameters of this object.

Definition at line 1163 of file MooseApp.h.

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

_parser

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

protected

Parser for parsing the input file.

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

Referenced by perfGraph(), and setupOptions().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_rank_map

const RankMap MooseApp::_rank_map

protected

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

Definition at line 1233 of file MooseApp.h.

Referenced by rankMap().

_rd_reader

RestartableDataReader MooseApp::_rd_reader

private

Definition at line 1546 of file MooseApp.h.

Referenced by finalizeRestore(), and restore().

_ready_to_exit

bool MooseApp::_ready_to_exit

protected

Definition at line 1283 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 1297 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 1224 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 1327 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 1300 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 1315 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 1218 of file MooseApp.h.

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

_restartable_meta_data

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

private

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

Definition at line 1513 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 1230 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 1303 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 1187 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 1184 of file MooseApp.h.

Referenced by hasStartTime(), and setStartTime().

_syntax

Syntax MooseApp::_syntax

protected

Syntax of the input file.

Definition at line 1196 of file MooseApp.h.

Referenced by setupOptions(), and syntax().

_sys_info

std::unique_ptr<SystemInfo> MooseApp::_sys_info

protected

System Information.

Definition at line 1267 of file MooseApp.h.

Referenced by getSystemInfo().

_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 1573 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 1318 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 1523 of file MooseApp.h.

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

_trap_fpe

bool MooseApp::_trap_fpe

protected

Whether or not FPE trapping should be turned on.

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

_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 1338 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 1264 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 1255 of file MooseApp.h.

Referenced by executeExecutioner(), and useExecutor().

_use_master_mesh

const bool MooseApp::_use_master_mesh

private

Whether to use the parent app mesh for this app.

Definition at line 1532 of file MooseApp.h.

Referenced by useMasterMesh().

_use_nonlinear

bool MooseApp::_use_nonlinear

protected

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

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

MESH_META_DATA

const RestartableDataMapName MooseApp::MESH_META_DATA = "MeshMetaData"

static

Definition at line 123 of file MooseApp.h.

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

MESH_META_DATA_SUFFIX

const RestartableDataMapName MooseApp::MESH_META_DATA_SUFFIX = "mesh"

static

Definition at line 124 of file MooseApp.h.

---

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

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