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
std::optional< MooseEnum >	getComputeDevice () const
	Get the device accelerated computations are supposed to be running on.

torch::DeviceType	getLibtorchDevice () const
	Get the device torch is supposed to be running on.

virtual	~MooseApp ()

TheWarehouse &	theWarehouse ()

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

virtual std::string	appBinaryName () const

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

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

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

PerfGraph &	perfGraph ()
	Get the PerfGraph for this app.

virtual void	run ()
	Run the application.

std::string	getFrameworkVersion () const
	Returns the framework version.

virtual std::string	getVersion () const
	Returns the current version of the framework or application (default: framework version).

std::string	getPrintableVersion () const
	Non-virtual method for printing out the version string in a consistent format.

virtual void	setupOptions ()
	Setup options based on InputParameters.

ActionWarehouse &	actionWarehouse ()
	Return a writable reference to the ActionWarehouse associated with this app.

const ActionWarehouse &	actionWarehouse () const
	Return a const reference to the ActionWarehouse associated with this app.

Moose::Builder &	builder ()
	Returns a writable reference to the builder.

Syntax &	syntax ()
	Returns a writable reference to the syntax object.

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.

std::string	getOutputFileBase (bool for_non_moose_build_output=false) const
	Get the output file base name.

void	setOutputPosition (const Point &p)
	Tell the app to output in a specific position.

std::list< std::string >	getCheckpointDirectories () const
	Get all checkpoint directories.

std::list< std::string >	getCheckpointFiles () const
	Extract all possible checkpoint file names.

bool	hasOutputPosition () const
	Whether or not an output position has been set.

Point	getOutputPosition () const
	Get the output position.

void	setStartTime (Real time)
	Set the starting time for the simulation.

bool	hasStartTime () const

Real	getStartTime () const

void	setGlobalTimeOffset (Real offset)
	Each App has it's own local time.

Real	getGlobalTimeOffset () const
	Each App has it's own local time.

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.

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

void	disableCheckUnusedFlag ()
	Removes warnings and error checks for unrecognized variables in the input file.

Executioner *	getExecutioner () const
	Retrieve the Executioner for this App.

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.

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.

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

Executor &	getExecutor (const std::string &name, bool fail_if_not_found=true)
	Get an Executor.

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.

bool &	useNonlinear ()
	Returns a writable Boolean indicating whether this app will use a Nonlinear or Eigen System.

bool &	useEigenvalue ()
	Returns a writable Boolean indicating whether this app will use an eigenvalue executioner.

Factory &	getFactory ()
	Retrieve a writable reference to the Factory associated with this App.

ActionFactory &	getActionFactory ()
	Retrieve a writable reference to the ActionFactory associated with this App.

processor_id_type	processor_id () const
	Returns the MPI processor ID of the current processor.

std::shared_ptr< CommandLine >	commandLine () const
	Get the command line.

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.

bool	getExodusFileRestart () const
	Whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh.

void	setExReaderForRestart (std::shared_ptr< libMesh::ExodusII_IO > &&exreader)
	Set the Exodus reader to restart variables from an Exodus mesh file.

libMesh::ExodusII_IO *	getExReaderForRestart () const
	Get the Exodus reader to restart variables from an Exodus mesh file.

virtual void	runInputFile ()
	Actually build everything in the input file.

virtual void	executeExecutioner ()
	Execute the Executioner that was built.

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

bool	isRecovering () const
	Whether or not this is a "recover" calculation.

bool	isRestarting () const
	Whether or not this is a "restart" calculation.

bool	isSplitMesh () const
	Whether or not this is a split mesh operation.

void	setRestartRecoverFileBase (const std::string &file_base)
	mutator for recover_base (set by RecoverBaseAction)

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

bool	testReStep () const
	Whether or not this simulation should fail a timestep and repeat (for testing).

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.

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.

OutputWarehouse &	getOutputWarehouse ()
	Get the OutputWarehouse objects.

const OutputWarehouse &	getOutputWarehouse () const

const SystemInfo &	getSystemInfo () const
	Get SystemInfo object.

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)

std::string	libNameToAppName (const std::string &library_name) const
	Converts a library name to an application name:

std::set< std::string >	getLoadedLibraryPaths () const
	Return the paths of loaded libraries.

std::set< std::string >	getLibrarySearchPaths (const std::string &library_path_from_param) const
	Return the paths searched by MOOSE when loading libraries.

InputParameterWarehouse &	getInputParameterWarehouse ()
	Get the InputParameterWarehouse for MooseObjects.

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

void	loadRestartableMetaData (const std::filesystem::path &folder_base)
	Loads all available restartable meta data if it is available with the folder base `folder_base`.

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

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

RestartableDataMap &	getRestartableDataMap (const RestartableDataMapName &name)
	Return a reference to restartable data for the specific type flag.

bool	hasRestartableDataMap (const RestartableDataMapName &name) const

void	registerRestartableDataMapName (const RestartableDataMapName &name, std::string suffix="")
	Reserve a location for storing custom RestartableDataMap objects.

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

const DataNames &	getRecoverableData () const
	Return a reference to the recoverable data object.

std::vector< std::filesystem::path >	backup (const std::filesystem::path &folder_base)
	Backs up the application to the folder `folder_base`.

std::unique_ptr< Backup >	backup ()
	Backs up the application memory in a Backup.

bool	hasInitialBackupMesh () const
	Whether this app has an initial Backup object with mesh checkpoint entries.

bool	restoredInitialBackupMesh () const
	Whether this app has restored mesh topology from its initial Backup object.

void	markMeshChangedForBackup ()
	Mark this app as requiring mesh topology data in its next Backup object.

bool	meshChangedForBackup () const
	Whether this app requires mesh topology data in its next Backup object.

void	restoreMeshFromInitialBackup (MooseMesh &mesh)
	Restore `mesh` from this app's initial Backup object and consume the mesh checkpoint entries.

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

void	restore (const std::filesystem::path &folder_base, const bool for_restart)
	Restore an application from file.

void	restore (std::unique_ptr< Backup > backup, const bool for_restart)
	Restore an application from the backup `backup`.

virtual void	postRestore (const bool)
	Insertion point for other apps that is called after restore()

void	restoreFromInitialBackup (const bool for_restart)
	Restores from a "initial" backup, that is, one set in _initial_backup.

std::unique_ptr< Backup >	finalizeRestore ()
	Finalizes (closes) the restoration process done in restore().

bool	restoreDataIfAvailable (RestartableDataValue &value, const THREAD_ID tid, Moose::PassKey< ReporterData >)
	Restores `value` in place from the checkpoint reader if it is present in the checkpoint and has not yet been loaded.

virtual std::string	header () const
	Returns a string to be printed at the beginning of a simulation.

unsigned int	multiAppLevel () const
	The MultiApp Level.

unsigned int	multiAppNumber () const
	The MultiApp number.

bool	isUltimateMaster () const
	Whether or not this app is the ultimate master app.

bool	useMasterMesh () const
	Returns whether to use the parent app mesh as the mesh for this app.

const MooseMesh *	masterMesh () const
	Returns a pointer to the master mesh.

const MooseMesh *	masterDisplacedMesh () const
	Returns a pointer to the master displaced mesh.

MeshGeneratorSystem &	getMeshGeneratorSystem ()
	Gets the system that manages the MeshGenerators.

ChainControlDataSystem &	getChainControlDataSystem ()
	Gets the system that manages the ChainControls.

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.

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.

virtual bool	constructingMeshGenerators () const
	Whether this app is constructing mesh generators.

bool	checkInput () const
	Returns whether the Application is running in check input mode.

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

bool	hasRelationshipManager (const std::string &name) const
	Returns a Boolean indicating whether a RelationshipManater exists with the same name.

bool	addRelationshipManager (std::shared_ptr< RelationshipManager > relationship_manager)
	Transfers ownership of a RelationshipManager to the application for lifetime management.

std::filesystem::path	restartFolderBase (const std::filesystem::path &folder_base) const
	The file suffix for restartable data.

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.

void	attachRelationshipManagers (MeshBase &mesh, MooseMesh &moose_mesh)
	Attach geometric relationship managers to the given `MeshBase` object.

const std::vector< std::shared_ptr< RelationshipManager > > &	getReleationshipManagers ()
	Retrieve the relationship managers.

std::vector< std::pair< std::string, std::string > >	getRelationshipManagerInfo () const
	Returns the Relationship managers info suitable for printing.

const ExecFlagEnum &	getExecuteOnEnum () const
	Return the app level ExecFlagEnum, this contains all the available flags for the app.

bool	hasInitialBackup () const

bool	defaultAutomaticScaling () const
	Whether to enable automatic scaling by default.

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

const std::set< std::shared_ptr< RelationshipManager > > &	relationshipManagers () const
	Return the container of relationship managers.

void	checkMetaDataIntegrity () const
	Function to check the integrity of the restartable meta data structure.

virtual bool	errorOnJacobianNonzeroReallocation () const
	Whether this application should by default error on Jacobian nonzero reallocations.

template<class T >
void	registerInterfaceObject (T &interface)
	Registers an interface object for accessing with getInterfaceObjects.

template<class T >
const std::vector< T * > &	getInterfaceObjects () const
	Gets the registered interface objects for a given interface.

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

bool	unusedFlagIsWarning () const
	Returns whether the flag for unused parameters is set to throw a warning only.

bool	unusedFlagIsError () const
	Returns whether the flag for unused parameters is set to throw an error.

void	setMFEMDevice (const std::string &device_string, bool gpu_aware_mpi, Moose::PassKey< MFEMProblemSolve >)
	Create/configure the MFEM device with the provided `device_string`.

std::shared_ptr< mfem::Device >	getMFEMDevice (Moose::PassKey< MultiApp >)
	Get the MFEM device object.

const std::set< std::string > &	getMFEMDevices (Moose::PassKey< MultiApp >) const
	Get the configured MFEM devices.

bool	isKokkosAvailable () const
	Get whether Kokkos is available.

void	allocateKokkosMemoryPool (std::size_t size, unsigned int ways) const
	Allocate Kokkos memory pool.

const Moose::Kokkos::MemoryPool &	getKokkosMemoryPool () const
	Get Kokkos memory pool.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

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

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

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

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

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

MooseObjectName	uniqueName () const

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

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

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

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

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

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

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

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.


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

const SolutionInvalidity &	solutionInvalidity () const


const Parser &	parser () const

Parser &	parser ()


bool	hasRestartRecoverFileBase () const
	Return true if the recovery file base is set.

bool	hasRecoverFileBase () const


std::string	getRestartRecoverFileBase () const
	The file_base for the recovery file.

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.

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.

std::vector< RestartableDataMap > &	getRestartableData ()


void	setRestart (bool value)
	Sets the restart/recover flags.

void	setRecover (bool value)


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

auto	getRestartableDataMapEnd ()

Static Public Member Functions
static InputParameters	validParams ()

static const std::string &	checkpointSuffix ()
	The file suffix for the checkpoint mesh.

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)

static void	addAppParam (InputParameters &params)

static void	addInputParam (InputParameters &params)

static bool	isRelocated ()

static bool	isInTree ()

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

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

Static Public Attributes
static const RestartableDataMapName	MESH_META_DATA = "MeshMetaData"

static const std::string	MESH_META_DATA_SUFFIX = "mesh"

static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

Protected 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
	FRIEND_TEST (::CapabilitiesTest, mooseAppAddBoolCapability)

	FRIEND_TEST (::CapabilitiesTest, mooseAppAddIntCapability)

	FRIEND_TEST (::CapabilitiesTest, mooseAppAddStringCapability)

	FRIEND_TEST (::CapabilitiesTest, mooseAppAddCapability)

void	dynamicRegistration (const libMesh::Parameters &params)
	Helper method for dynamic loading of objects.

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.

	MooseApp (const InputParameters &parameters)
	Constructor is protected so that this object is constructed through the AppFactory object.

void	registerRestartableNameWithFilter (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	NOTE: This is an internal function meant for MOOSE use only!

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

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

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

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

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

Static Protected Member Functions
static Moose::Capability &	addBoolCapability (const std::string_view capability, const bool value, const std::string_view doc)
	Register a boolean capability.

static Moose::Capability &	addIntCapability (const std::string_view capability, const int value, const std::string_view doc)
	Register an integer capability.

static Moose::Capability &	addStringCapability (const std::string_view capability, const std::string_view value, const std::string_view doc)
	Register a string capability.

static Moose::Capability &	addCapability (const std::string_view capability, const Moose::Capability::Value &value, const std::string_view doc)
	Deprecated method for adding a capability.

Protected Attributes
const std::string	_type
	The string representation of the type of this object as registered (see registerApp(AppName))

const std::shared_ptr< libMesh::Parallel::Communicator >	_comm
	The MPI communicator this App is going to use.

std::string	_output_file_base
	The output file basename.

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

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

Point	_output_position
	The output position.

bool	_start_time_set
	Whether or not an start time has been set.

Real	_start_time
	The time at which to start the simulation.

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

Syntax	_syntax
	Syntax of the input file.

std::unique_ptr< InputParameterWarehouse >	_input_parameter_warehouse
	Input parameter storage structure; unique_ptr so we can control its destruction order.

ActionFactory	_action_factory
	The Factory responsible for building Actions.

ActionWarehouse	_action_warehouse
	Where built actions are stored.

OutputWarehouse	_output_warehouse
	OutputWarehouse object for this App.

const std::shared_ptr< Parser >	_parser
	Parser for parsing the input file (owns the root hit node)

const std::shared_ptr< CommandLine >	_command_line
	The CommandLine object.

SystemInfo	_sys_info
	System Information.

Moose::Builder	_builder
	Builder for building app related parser tree.

std::vector< RestartableDataMap >	_restartable_data
	Where the restartable data is held (indexed on tid)

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

PerfGraph &	_perf_graph
	The PerfGraph object for this application (recoverable)

SolutionInvalidity &	_solution_invalidity
	The SolutionInvalidity object for this application.

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

std::shared_ptr< Executioner >	_executioner
	Pointer to the executioner of this run (typically build by actions)

std::shared_ptr< Executor >	_executor
	Pointer to the Executor of this run.

std::map< std::string, std::shared_ptr< Executor > >	_executors
	Pointers to all of the Executors for this run.

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>

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

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

std::shared_ptr< NullExecutor >	_null_executor
	Used to return an executor that does nothing.

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

bool	_use_eigen_value
	Boolean to indicate whether to use an eigenvalue executioner.

enum MooseApp::UNUSED_CHECK	_enable_unused_check

Factory	_factory

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

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

bool	_ready_to_exit

int	_exit_code
	The exit code.

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

std::shared_ptr< libMesh::ExodusII_IO >	_ex_reader
	The Exodus reader when _initial_from_file is set to true.

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

bool	_recover
	Whether or not this is a recovery run.

bool	_restart
	Whether or not this is a restart run.

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

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

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

bool	_trap_fpe
	Whether or not FPE trapping should be turned on.

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

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

const bool	_test_restep
	Whether or not this simulation should fail its middle timestep and repeat (for testing)

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)

const bool	_check_input
	true if we want to just check the input file

std::set< std::shared_ptr< RelationshipManager > >	_relationship_managers
	The relationship managers that have been added.

std::map< Moose::RelationshipManagerType, std::set< const RelationshipManager * > >	_attached_relationship_managers
	The relationship managers that have been attached (type -> RMs)

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

std::unordered_map< std::string, DynamicLibraryInfo >	_lib_handles
	The library archive (name only), registration method and the handle to the method.

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.

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

const Parallel::Communicator &	_communicator

MooseApp &	_app
	The MOOSE application this is associated with.

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

const InputParameters &	_pars
	The object's parameters.

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.

void	removeRelationshipManager (std::shared_ptr< RelationshipManager > relationship_manager)
	Purge this relationship manager from meshes and DofMaps and finally from us.

torch::DeviceType	determineLibtorchDeviceType (const MooseEnum &device) const
	Function to determine the device which should be used by libtorch on this application.

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

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.

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.

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

PerfGraph &	createRecoverablePerfGraph ()
	Creates a recoverable PerfGraph.

SolutionInvalidity &	createRecoverableSolutionInvalidity ()
	Creates a recoverable SolutionInvalidity.

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

virtual std::string	getInstallableInputs () const
	Method to retrieve the installable inputs from a given applications <app>Revision.h file.

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.

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.

void	requestCitations ()
	Handles the –citations command-line option: registers with PETSc the BibTeX entries that should be cited for the framework and the modules/objects used in this simulation, and enables PETSc's -citations option.

void	collectCitations (std::map< std::string, std::string > &citations) const
	Collects the BibTeX citations for the modules/objects constructed in this app and the finite element backend it uses, then recurses into every MultiApp subapp to do the same.

void	queryKokkosGPUs ()
	Query the Kokkos GPUs in the system and check whether every process has an associated GPU.

void	deallocateKokkosMemoryPool ()
	Deallocate Kokkos memory pool.

Static Private Member Functions
static Moose::Capability &	addCapabilityInternal (const std::string_view capability, const Moose::Capability::Value &value, const std::string_view doc)
	Internal method for adding a capability.

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

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

Private Attributes
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > >	_restartable_meta_data
	General storage for custom RestartableData that can be added to from outside applications.

std::unique_ptr< TheWarehouse >	_the_warehouse
	The combined warehouse for storing any MooseObject based object.

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

const unsigned int	_multiapp_number
	Numbering in all the sub-apps on the same level.

const bool	_use_master_mesh
	Whether to use the parent app mesh for this app.

const MooseMesh *const	_master_mesh
	The mesh from master app.

const MooseMesh *const	_master_displaced_mesh
	The displaced mesh from master app.

MeshGeneratorSystem	_mesh_generator_system
	The system that manages the MeshGenerators.

ChainControlDataSystem	_chain_control_system
	The system that manages the ChainControls.

RestartableDataReader	_rd_reader

const ExecFlagEnum	_execute_flags
	Execution flags for this App.

std::streambuf *	_output_buffer_cache
	Cache output buffer so the language server can turn it off then back on.

const bool	_automatic_automatic_scaling
	Whether to turn on automatic scaling by default.

bool	_cpu_profiling = false
	CPU profiling.

bool	_heap_profiling = false
	Memory profiling.

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.

std::map< std::type_index, std::unique_ptr< InterfaceRegistryObjectsBase > >	_interface_registry
	Registration for interface objects.

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.

bool	_restored_initial_backup_mesh = false
	Whether mesh topology has been restored from the initial Backup object.

bool	_mesh_changed_for_backup = false
	Whether mesh topology has changed and should be included in Backup objects.

const torch::DeviceType	_libtorch_device
	The libtorch device this app is using (converted from compute_device)

std::shared_ptr< mfem::Device >	_mfem_device
	The MFEM Device object.

std::set< std::string >	_mfem_devices
	MFEM supported devices based on user-provided config.

bool	_has_kokkos_gpus = false
	Flag whether every process has an associated Kokkos GPU.

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 109 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 1667 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 1395 of file MooseApp.h.

  {
    OFF,
    WARN_UNUSED,
    ERROR_UNUSED
  } _enable_unused_check;

Constructor & Destructor Documentation

◆ ~MooseApp()

virtual MooseApp::~MooseApp ( )

virtual

◆ MooseApp()

MooseApp::MooseApp ( const InputParameters & parameters )

protected

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

Definition at line 626 of file MooseApp.C.

  : 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(*this, 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(getCheckedPointerParam<std::shared_ptr<Parser>>("_parser")),
    _command_line(getCheckedPointerParam<std::shared_ptr<CommandLine>>("_command_line")),
    _builder(*this, _action_warehouse, *_parser),
    _restartable_data(libMesh::n_threads()),
    _perf_graph(createRecoverablePerfGraph()),
    _solution_invalidity(createRecoverableSolutionInvalidity()),
    _rank_map(*_comm, _perf_graph),
    _use_executor(getParam<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(getParam<bool>("distributed_mesh")),
    _recover(false),
    _restart(false),
    _split_mesh(false),
    _use_split(getParam<bool>("use_split")),
    _force_restart(getParam<bool>("force_restart")),
#ifdef DEBUG
    _trap_fpe(true),
#else
    _trap_fpe(false),
#endif
    _test_checkpoint_half_transient(parameters.get<bool>("test_checkpoint_half_transient")),
    _test_restep(parameters.get<bool>("test_restep")),
    _check_input(getParam<bool>("check_input")),
    _multiapp_level(isParamValid("_multiapp_level") ? getParam<unsigned int>("_multiapp_level")
                                                    : 0),
    _multiapp_number(isParamValid("_multiapp_number") ? getParam<unsigned int>("_multiapp_number")
                                                      : 0),
    _use_master_mesh(getParam<bool>("_use_master_mesh")),
    _master_mesh(isParamValid("_master_mesh") ? getParam<const MooseMesh *>("_master_mesh")
                                              : nullptr),
    _master_displaced_mesh(isParamValid("_master_displaced_mesh")
                               ? getParam<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>("compute_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") ? getParam<std::set<std::string>>("_mfem_devices")
                                                : std::set<std::string>{})
#endif
{
  if (&parameters != &_pars)
  {
    const std::string bad_params = "(InputParameters parameters)";
    const std::string good_params = "(const InputParameters & parameters)";
    const std::string source_constructor = type() + "::" + type();
    mooseDoOnce(
        mooseDeprecatedNoTrace(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,
                               ";"));
  }
 
  mooseAssert(_command_line->hasParsed(), "Command line has not parsed");
  mooseAssert(_parser->queryRoot(), "Parser has not parsed");
 
  // Set the TIMPI sync type via --timpi-sync
  const auto & timpi_sync = getParam<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<AttribKokkos>("kokkos", false);
  _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 (_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 (isParamSetByUser("show_actions"))
    _action_warehouse.showActions(true);
 
  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.");
 
  if (_test_restep && _test_checkpoint_half_transient)
    mooseError("Cannot use --test-restep and --test-checkpoint-half-transient together");
 
  Moose::out << std::flush;
 
#ifdef MOOSE_KOKKOS_ENABLED
#ifdef MOOSE_ENABLE_KOKKOS_GPU
  queryKokkosGPUs();
#endif
#endif
}
 
std::optional<MooseEnum>
MooseApp::getComputeDevice() const
{
  if (isParamSetByUser("compute_device"))
    return getParam<MooseEnum>("compute_device");
  return {};
}
 
MooseApp::~MooseApp()
{
#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. This allows
  // for creating an app with this name again in the same execution,
  // which needs to be done when resetting applications in MultiApp
  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
 
#ifdef MOOSE_KOKKOS_ENABLED
  deallocateKokkosMemoryPool();
#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 217 of file MooseApp.h.

217{ return _action_warehouse; }

Referenced by ElementIDOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), SplitMeshAction::act(), MeshGeneratorSystem::appendingMeshGenerators(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Console::Console(), MeshGeneratorSystem::createAddedMeshGenerators(), MeshGeneratorSystem::createMeshGeneratorOrder(), MeshGeneratorSystem::dataDrivenError(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), MeshGeneratorSystem::getCSGBaseGeneratorOutput(), 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().

◆ actionWarehouse() [2/2]

const ActionWarehouse & MooseApp::actionWarehouse ( ) const

inline

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

Definition at line 221 of file MooseApp.h.

221{ return _action_warehouse; }

◆ addAppParam()

void MooseApp::addAppParam ( InputParameters & params )

static

Definition at line 261 of file MooseApp.C.

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

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

◆ addBoolCapability()

Moose::Capability & MooseApp::addBoolCapability	(	const std::string_view	capability,
		const bool	value,
		const std::string_view	doc
	)

staticprotected

Register a boolean capability.

Parameters

capability	The name of the capability
value	The value of the boolean capability
doc	The documentation string

Returns: The capability

Definition at line 3576 of file MooseApp.C.

{
  return addCapabilityInternal(capability, value, doc);
}

◆ addCapability()

Moose::Capability & MooseApp::addCapability	(	const std::string_view	capability,
		const Moose::Capability::Value &	value,
		const std::string_view	doc
	)

staticprotected

Deprecated method for adding a capability.

It is deprecated due to ambiguity between compilers with an implicit conversion for CapabilityValue (a variant).

Use one of add[Bool,Int,String]Capability instead.

Parameters

capability	The name of the capability
value	The value of the capability
doc	The documentation string

Returns: The capability

Definition at line 3600 of file MooseApp.C.

{
 
  // Warn deprecation on the first time this is added so that we
  // don't get multiple warnings if the app is registered more
  // than once
  if (!Moose::internal::Capabilities::getCapabilities({}).query(std::string(capability)))
    ::mooseDeprecated("MooseApp::addCapability() is deprecated (adding capability '",
                      capability,
                      "'); use one of MooseApp::add[Bool,Int,String]Capability instead.");
 
  return addCapabilityInternal(capability, value, doc);
}

◆ addCapabilityInternal()

Moose::Capability & MooseApp::addCapabilityInternal	(	const std::string_view	capability,
		const Moose::Capability::Value &	value,
		const std::string_view	doc
	)

staticprivate

Internal method for adding a capability.

Used to catch exceptions and report them as a mooseError.

Parameters

capability	The name of the capability
value	The value of the capability
doc	The documentation string

Returns: The capability

Definition at line 2336 of file MooseApp.C.

{
  try
  {
    return Moose::internal::Capabilities::getCapabilities({}).add(capability, value, doc);
  }
  catch (const std::exception & e)
  {
    ::mooseError(e.what());
  }
}

Referenced by addBoolCapability(), addCapability(), addIntCapability(), and addStringCapability().

◆ addExecutor()

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

Definition at line 1864 of file MooseApp.C.

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

Referenced by recursivelyCreateExecutors().

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

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

Referenced by ReadExecutorParamsAction::act().

◆ addInputParam()

void MooseApp::addInputParam ( InputParameters & params )

static

Definition at line 268 of file MooseApp.C.

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

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

◆ addIntCapability()

Moose::Capability & MooseApp::addIntCapability	(	const std::string_view	capability,
		const int	value,
		const std::string_view	doc
	)

staticprotected

Register an integer capability.

Parameters

capability	The name of the capability
value	The value of the integer capability
doc	The documentation string

Returns: The capability

Definition at line 3584 of file MooseApp.C.

{
  return addCapabilityInternal(capability, value, doc);
}

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

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

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

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

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

Referenced by AdaptivityAction::act(), AddPeriodicBCAction::act(), SetAdaptivityOptionsAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), and FunctorSmootherTempl< T >::FunctorSmootherTempl().

◆ addStringCapability()

Moose::Capability & MooseApp::addStringCapability	(	const std::string_view	capability,
		const std::string_view	value,
		const std::string_view	doc
	)

staticprotected

Register a string capability.

Parameters

capability	The name of the capability
value	The value of the string capability
doc	The documentation string

Returns: The capability

Definition at line 3592 of file MooseApp.C.

{
  return addCapabilityInternal(capability, std::string(value), doc);
}

◆ allocateKokkosMemoryPool()

void MooseApp::allocateKokkosMemoryPool	(	std::size_t	size,
		unsigned int	ways
	)		const

Allocate Kokkos memory pool.

Parameters

size	The memory pool size in the number of bytes
ways	The number of parallel ways

◆ appBinaryName()

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

inlinevirtual

Definition at line 150 of file MooseApp.h.

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

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

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

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

Referenced by dynamicAllRegistration(), and dynamicAppRegistration().

◆ attachRelationshipManagers() [1/2]

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

Attach geometric relationship managers to the given MeshBase object.

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

Definition at line 3176 of file MooseApp.C.

{
  for (auto & rm : _relationship_managers)
  {
    if (rm->isType(Moose::RelationshipManagerType::GEOMETRIC))
    {
      if (rm->attachGeometricEarly())
      {
        mesh.add_ghosting_functor(createRMFromTemplateAndInit(*rm, moose_mesh, mesh));
        _attached_relationship_managers[Moose::RelationshipManagerType::GEOMETRIC].insert(rm.get());
      }
      else
      {
        // If we have a geometric ghosting functor that can't be attached early, then we have to
        // prevent the mesh from deleting remote elements
        moose_mesh.allowRemoteElementRemoval(false);
 
        if (const MeshBase * const moose_mesh_base = moose_mesh.getMeshPtr())
        {
          if (moose_mesh_base != &mesh)
            mooseError("The MooseMesh MeshBase and the MeshBase we're trying to attach "
                       "relationship managers to are different");
        }
        else
          // The MeshBase isn't attached to the MooseMesh yet, so have to tell it not to remove
          // remote elements independently
          mesh.allow_remote_element_removal(false);
      }
    }
  }
}

◆ attachRelationshipManagers() [2/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 3209 of file MooseApp.C.

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

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

◆ backup() [1/2]

std::unique_ptr< Backup > MooseApp::backup ( )

Backs up the application memory in a Backup.

Returns: The backup

Definition at line 1732 of file MooseApp.C.

{
  TIME_SECTION("backup", 2, "Backing Up Application");
 
  RestartableDataWriter writer(*this, _restartable_data);
 
  preBackup();
 
  auto backup = std::make_unique<Backup>();
  packMeshBackup(*this, *backup);
  writer.write(*backup->header, *backup->data);
 
  return backup;
}

Referenced by backup(), finalizeRestore(), and restore().

◆ backup() [2/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 1721 of file MooseApp.C.

{
  TIME_SECTION("backup", 2, "Backing Up Application to File");
 
  preBackup();
 
  RestartableDataWriter writer(*this, _restartable_data);
  return writer.write(folder_base);
}

Referenced by Checkpoint::output().

◆ builder()

Moose::Builder & MooseApp::builder ( )

inline

Returns a writable reference to the builder.

Definition at line 226 of file MooseApp.h.

226{ return _builder; }

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

◆ callMooseError() [1/2]

void MooseBase::callMooseError	(	MooseApp *const	app,
		const InputParameters &	params,
		std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node,
		const bool	show_trace = `true`
	)

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

◆ callMooseError() [2/2]

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node = `nullptr`,
		const bool	show_trace = `true`
	)		const

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

{
  callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
}

Referenced by MooseBase::callMooseError(), InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

◆ checkInput()

bool MooseApp::checkInput ( ) const

inline

Returns whether the Application is running in check input mode.

Definition at line 976 of file MooseApp.h.

976{ return _check_input; }

◆ checkMetaDataIntegrity()

void MooseApp::checkMetaDataIntegrity ( ) const

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

Definition at line 3400 of file MooseApp.C.

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

Referenced by SetupRecoverFileBaseAction::act().

◆ checkpointSuffix()

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

static

The file suffix for the checkpoint mesh.

Definition at line 3044 of file MooseApp.C.

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

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

◆ collectCitations()

void MooseApp::collectCitations ( std::map< std::string, std::string > & citations ) const

private

Collects the BibTeX citations for the modules/objects constructed in this app and the finite element backend it uses, then recurses into every MultiApp subapp to do the same.

The map is keyed by BibTeX key so a citation shared across apps is folded in only once.

Definition at line 2106 of file MooseApp.C.

{
  // Gather the citations that apply to this app: for every object type actually constructed, the
  // citations registered for its owning app/module. The framework paper is tied to "MooseApp", so
  // it is gathered whenever a MooseApp object is used; apps composed of MooseApp inherit it. The
  // map is keyed by BibTeX key so a citation shared across apps is folded in only once.
  for (const auto & objname : _factory.getConstructedObjects())
  {
    mooseAssert(Registry::isRegisteredObj(objname),
                "Constructed object '" + objname + "' is not registered");
    const auto & app_citations = Registry::getCitations(Registry::objData(objname)._label);
    citations.insert(app_citations.begin(), app_citations.end());
  }
 
  // Credit the finite element backend actually used in the run. These are mutually exclusive, so
  // only the backend in use is cited.
  std::string backend = "libMesh";
#ifdef MOOSE_MFEM_ENABLED
  if ((_executor || _executioner) && feProblem().feBackend() == Moose::FEBackend::MFEM)
    backend = "MFEM";
#endif
  const auto & backend_citations = Registry::getCitations(backend);
  citations.insert(backend_citations.begin(), backend_citations.end());
 
  // Recurse into the MultiApp subapps so that objects/modules used only inside subapps are still
  // attributed. Each subapp is a separate MooseApp whose run() (and thus requestCitations()) is
  // never called, so the master gathers their citations here. feProblem() asserts when there is no
  // executioner, so only descend once one exists; nested MultiApps are handled by the recursion.
  if (_executor || _executioner)
    for (const auto & multi_app : feProblem().getMultiAppWarehouse().getObjects())
      for (const auto i : make_range(multi_app->numLocalApps()))
        multi_app->localApp(i)->collectCitations(citations);
}

Referenced by requestCitations().

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

424{ return _command_line; }

Referenced by MultiApp::createApp(), Moose::Builder::errorCheck(), ConsoleUtils::outputExecutionInformation(), ConsoleUtils::outputFrameworkInformation(), and MooseServer::parseDocumentForDiagnostics().

◆ connectControllableParams()

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

inherited

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

Parameters

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

Definition at line 77 of file MooseBase.C.

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

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

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

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

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

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

Referenced by run().

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

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

Referenced by AddExecutorAction::act().

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

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

Referenced by setupOptions().

◆ 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 3468 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 3486 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 3140 of file MooseApp.C.

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

Referenced by attachRelationshipManagers(), and attachRelationshipManagers().

◆ deallocateKokkosMemoryPool()

void MooseApp::deallocateKokkosMemoryPool ( )

private

Deallocate Kokkos memory pool.

◆ defaultAutomaticScaling()

bool MooseApp::defaultAutomaticScaling ( ) const

inline

Whether to enable automatic scaling by default.

Definition at line 1055 of file MooseApp.h.

1055{ return _automatic_automatic_scaling; }

Referenced by FEProblemSolve::FEProblemSolve().

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

{
  const auto pname = "--compute-device";
  if (device_enum == "cuda")
  {
#ifdef __linux__
    if (!torch::cuda::is_available())
      mooseError(pname, "=cuda: CUDA support is not available in the linked libtorch library");
    return torch::kCUDA;
#else
    mooseError(pname, "=cuda: CUDA is not supported on your platform");
#endif
  }
  else if (device_enum == "mps")
  {
#ifdef __APPLE__
    if (!torch::mps::is_available())
      mooseError(pname, "=mps: MPS support is not available in the linked libtorch library");
    return torch::kMPS;
#else
    mooseError(pname, "=mps: MPS is not supported on your platform");
#endif
  }
  else if (device_enum == "xpu")
  {
#ifdef MOOSE_HAVE_XPU
    if (!torch::xpu::is_available())
      mooseError(pname, "=xpu: XPU support is not available in the linked libtorch library");
    return torch::kXPU;
#else
    mooseError(pname, "=xpu: XPU is not supported in the current application");
#endif
  }
  else if (device_enum != "cpu")
    mooseError("The device '",
               device_enum,
               "' is not currently supported by the MOOSE libtorch integration.");
  return torch::kCPU;
}

◆ disableCheckUnusedFlag()

void MooseApp::disableCheckUnusedFlag ( )

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

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

{
#ifdef LIBMESH_HAVE_DLOPEN
  libMesh::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
}

Referenced by DynamicObjectRegistrationAction::DynamicObjectRegistrationAction().

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

{
#ifdef LIBMESH_HAVE_DLOPEN
  libMesh::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
}

Referenced by MultiApp::createApps().

◆ dynamicRegistration()

void MooseApp::dynamicRegistration ( const libMesh::Parameters & params )

protected

Helper method for dynamic loading of objects.

Definition at line 2672 of file MooseApp.C.

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

Referenced by dynamicAllRegistration(), and dynamicAppRegistration().

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

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

Referenced by errorCheck(), executeExecutioner(), and run().

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

1089{ return false; }

◆ errorPrefix()

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

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ executeExecutioner()

void MooseApp::executeExecutioner ( )

virtual

Execute the Executioner that was built.

Definition at line 1642 of file MooseApp.C.

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

Referenced by run().

◆ exitCode()

int MooseApp::exitCode ( ) const

inline

Get the shell exit code for the application.

Returns: The shell exit code

Definition at line 163 of file MooseApp.h.

163{ return _exit_code; }

Referenced by copyInputs().

◆ feProblem()

FEProblemBase & MooseApp::feProblem ( ) const

Definition at line 1857 of file MooseApp.C.

{
  mooseAssert(_executor.get() || _executioner.get(), "No executioner yet, calling too early!");
  return _executor.get() ? _executor->feProblem() : _executioner->feProblem();
}

Referenced by attachRelationshipManagers(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), collectCitations(), errorCheck(), AutomaticMortarGeneration::initOutput(), MortarNodalGeometryOutput::output(), removeRelationshipManager(), restore(), setOutputFileBase(), and MooseMesh::update().

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

{
  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);
    packMeshBackup(*this, *backup);
  }
 
  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 392 of file MooseApp.h.

392{ return _fixed_point_config; }

MooseApp::_fixed_point_config

FixedPointConfig _fixed_point_config

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

Definition MooseApp.h:1379

Referenced by FixedPointSolve::FixedPointSolve().

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

1114{ return _force_restart; }

Referenced by possiblyLoadRestartableMetaData().

◆ FRIEND_TEST() [1/4]

MooseApp::FRIEND_TEST	(	::CapabilitiesTest	,
		mooseAppAddBoolCapability
	)

protected

◆ FRIEND_TEST() [2/4]

MooseApp::FRIEND_TEST	(	::CapabilitiesTest	,
		mooseAppAddCapability
	)

protected

◆ FRIEND_TEST() [3/4]

MooseApp::FRIEND_TEST	(	::CapabilitiesTest	,
		mooseAppAddIntCapability
	)

protected

◆ FRIEND_TEST() [4/4]

MooseApp::FRIEND_TEST	(	::CapabilitiesTest	,
		mooseAppAddStringCapability
	)

protected

◆ getActionFactory()

ActionFactory & MooseApp::getActionFactory ( )

inline

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

Definition at line 412 of file MooseApp.h.

412{ return _action_factory; }

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

◆ getBase()

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

inlineinherited

Returns: The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by MooseBase::uniqueParameterName().

◆ getChainControlDataSystem()

ChainControlDataSystem & MooseApp::getChainControlDataSystem ( )

inline

Gets the system that manages the ChainControls.

Definition at line 891 of file MooseApp.h.

891{ return _chain_control_system; }

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

◆ getCheckedPointerParam()

template<typename T >

T MooseBase::getCheckedPointerParam	(	const std::string &	name,
		const std::string &	error_string = `""`
	)		const

inherited

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

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

Definition at line 450 of file MooseBase.h.

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

◆ getCheckpointDirectories()

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

Get all checkpoint directories.

Returns: A Set of checkpoint directories

Definition at line 2362 of file MooseApp.C.

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

Referenced by getCheckpointFiles().

◆ getCheckpointFiles()

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

Extract all possible checkpoint file names.

Returns: A Set of checkpoint filenames

Definition at line 2394 of file MooseApp.C.

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

Referenced by setRestartRecoverFileBase().

◆ getCommunicator()

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

inline

Definition at line 1058 of file MooseApp.h.

1058{ return _comm; }

Referenced by MooseServer::parseDocumentForDiagnostics().

◆ getComputeDevice()

std::optional< MooseEnum > MooseApp::getComputeDevice ( ) const

Get the device accelerated computations are supposed to be running on.

Referenced by MFEMProblemSolve::MFEMProblemSolve().

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

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

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

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

466{ return _distributed_mesh_on_command_line; }

Referenced by MooseMesh::determineUseDistributedMesh().

◆ getExecuteOnEnum()

const ExecFlagEnum & MooseApp::getExecuteOnEnum ( ) const

inline

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

Definition at line 1040 of file MooseApp.h.

1040{ return _execute_flags; }

Referenced by EigenExecutionerBase::normalizeSolution().

◆ getExecutioner()

Executioner * MooseApp::getExecutioner ( ) const

Retrieve the Executioner for this App.

Definition at line 2020 of file MooseApp.C.

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

Referenced by AddTimeStepperAction::act(), CheckIntegrityAction::act(), ComposeTimeStepperAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), LazyCoupleable::coupled(), EigenProblem::doFreeNonlinearPowerIterations(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), PseudoTimestep::execute(), IterationInfo::execute(), Terminator::execute(), ChangeOverFixedPointPostprocessor::finalize(), FVAdvection::FVAdvection(), DefaultConvergenceBase::getSharedExecutionerParam(), NumFixedPointIterations::getValue(), FEProblemBase::init(), Console::initialSetup(), NumFailedTimeSteps::NumFailedTimeSteps(), ConsoleUtils::outputExecutionInformation(), MultiApp::preTransfer(), MultiApp::restore(), setOutputFileBase(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), and MooseMesh::update().

◆ getExecutor() [1/2]

Executor * MooseApp::getExecutor ( ) const

inline

Definition at line 341 of file MooseApp.h.

341{ return _executor.get(); }

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

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

436{ return _initial_from_file; }

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

◆ getExReaderForRestart()

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

inline

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

Definition at line 449 of file MooseApp.h.

449{ return _ex_reader.get(); }

MooseApp::_ex_reader

std::shared_ptr< libMesh::ExodusII_IO > _ex_reader

The Exodus reader when _initial_from_file is set to true.

Definition MooseApp.h:1416

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

◆ getFactory()

Factory & MooseApp::getFactory ( )

inline

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

Definition at line 407 of file MooseApp.h.

407{ 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 2408 of file MooseApp.C.

{
  return _builder.getPrimaryFileName(stripLeadingPath);
}

Referenced by ProgressOutput::output().

◆ getFPTrapFlag()

bool MooseApp::getFPTrapFlag ( ) const

inline

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

Definition at line 979 of file MooseApp.h.

979{ return _trap_fpe; }

◆ getFrameworkVersion()

std::string MooseApp::getFrameworkVersion ( ) const

Returns the framework version.

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

318{ return _global_time_offset; }

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

◆ getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const

inlineinherited

Returns: The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

Referenced by MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

◆ getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters & params )

staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

◆ getInputFileNames()

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

Returns: the input file names set in the Parser

Definition at line 1523 of file MooseApp.C.

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

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

◆ getInputParameterWarehouse()

InputParameterWarehouse & MooseApp::getInputParameterWarehouse ( )

Get the InputParameterWarehouse for MooseObjects.

Definition at line 2872 of file MooseApp.C.

{
  return *_input_parameter_warehouse;
}

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

◆ getInstallableInputs()

std::string MooseApp::getInstallableInputs ( ) const

privatevirtual

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

Definition at line 2208 of file MooseApp.C.

{
  return "tests";
}

Referenced by showInputs().

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

{
  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 cast_ptr<InterfaceRegistryObjects<T> *>(it->second.get())->_objects;
  const static std::vector<T *> empty;
  return empty;
}

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

◆ getKokkosMemoryPool()

const Moose::Kokkos::MemoryPool & MooseApp::getKokkosMemoryPool ( ) const

Get Kokkos memory pool.

Returns: The Kokkos memory pool

◆ getLastInputFileName()

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

Returns: The last input filename set (if any)

Definition at line 1530 of file MooseApp.C.

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

Referenced by setupOptions().

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

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

Referenced by dynamicAppRegistration(), and dynamicRegistration().

◆ getLibtorchDevice()

torch::DeviceType MooseApp::getLibtorchDevice ( ) const

inline

Get the device torch is supposed to be running on.

Definition at line 117 of file MooseApp.h.

117{ return _libtorch_device; }

Referenced by NEML2Assembly::finalize(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), and NEML2FEInterpolation::updatePhi().

◆ getLoadedLibraryPaths()

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

Return the paths of loaded libraries.

Definition at line 2835 of file MooseApp.C.

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

Referenced by Factory::reportUnregisteredError().

◆ getMeshGenerator()

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

inline

Returns: The MeshGenerator with the name name.

Definition at line 920 of file MooseApp.h.

  {
    return _mesh_generator_system.getMeshGenerator(name);
  }

Referenced by MeshGenerator::generateInternal(), and MeshGenerator::generateInternalCSG().

◆ getMeshGeneratorMesh()

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

inline

Returns: The final mesh generated by the mesh generator system

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

  {
    return _mesh_generator_system.getMeshGeneratorNames();
  }

Referenced by SetupMeshAction::act().

◆ getMeshGeneratorSystem()

MeshGeneratorSystem & MooseApp::getMeshGeneratorSystem ( )

inline

Gets the system that manages the MeshGenerators.

Definition at line 886 of file MooseApp.h.

886{ return _mesh_generator_system; }

Referenced by CombineComponentsMeshes::act(), CreateAddedMeshGenerators::act(), CSGOnlyAction::act(), ExecuteMeshGenerators::act(), SetupMeshAction::act(), BatchMeshGeneratorAction::addMeshGenerators(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::checkGetMesh(), MeshGenerator::getCSGBaseByName(), MeshGenerator::getMeshByName(), BoundaryMeshBuilder::initialSetup(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::setupComponent(), and SetupDebugAction::SetupDebugAction().

◆ getMFEMDevice()

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

inline

Get the MFEM device object.

Definition at line 1134 of file MooseApp.h.

1134{ return _mfem_device; }

Referenced by MultiApp::createApp().

◆ getMFEMDevices()

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

inline

Get the configured MFEM devices.

Definition at line 1814 of file MooseApp.h.

{
  return _mfem_devices;
}

Referenced by MultiApp::createApp().

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), LinearFVGradientManager::checkRestartedGradientHistory(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), AuxiliarySystem::registerFVGradient(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

◆ getNullExecutor()

NullExecutor * MooseApp::getNullExecutor ( ) const

inline

Definition at line 342 of file MooseApp.h.

342{ return _null_executor.get(); }

Referenced by ExecutorInterface::getExecutor().

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

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

Referenced by CSGOnlyAction::act(), getCheckpointDirectories(), AutomaticMortarGeneration::outputMortarMesh(), OutputWarehouse::resetFileBase(), and MultiApp::setAppOutputFileBase().

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

  {
    return _output_file_numbers;
  }

Referenced by TransientMultiApp::setupApp().

◆ getOutputPosition()

Point MooseApp::getOutputPosition ( ) const

inline

Get the output position.

Returns: The position offset for the output.

Definition at line 288 of file MooseApp.h.

288{ return _output_position; }

MooseApp::_output_position

Point _output_position

The output position.

Definition MooseApp.h:1306

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

◆ getOutputWarehouse() [1/2]

OutputWarehouse & MooseApp::getOutputWarehouse ( )

Get the OutputWarehouse objects.

Definition at line 2414 of file MooseApp.C.

{
  return _output_warehouse;
}

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(), AutomaticMortarGeneration::initOutput(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), ConsoleUtils::outputFrameworkInformation(), ConsoleUtils::outputOutputInformation(), FEProblemBase::outputStep(), FEProblemBase::subdomainSetup(), and FEProblemBase::timestepSetup().

◆ getOutputWarehouse() [2/2]

const OutputWarehouse & MooseApp::getOutputWarehouse ( ) const

Definition at line 2420 of file MooseApp.C.

{
  return _output_warehouse;
}

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

◆ getPrintableName()

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

inlinevirtual

Get printable name of the application.

Definition at line 148 of file MooseApp.h.

148{ return "Application"; }

Referenced by getPrintableVersion().

◆ getPrintableVersion()

std::string MooseApp::getPrintableVersion ( ) const

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

Definition at line 1024 of file MooseApp.C.

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

Referenced by setupOptions().

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

727{ return _recoverable_data_names; }

MooseApp::_recoverable_data_names

DataNames _recoverable_data_names

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

Definition MooseApp.h:1352

Referenced by restore(), and restore().

◆ getRecoverFileBase()

std::string MooseApp::getRecoverFileBase ( ) const

inline

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

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

Referenced by ConsoleUtils::outputRelationshipManagerInformation().

◆ getReleationshipManagers()

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

Retrieve the relationship managers.

◆ getRenamedParam()

template<typename T >

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

inherited

Retrieve a renamed parameter for the object.

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

Parameters

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

Definition at line 420 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

◆ getRestartableData() [1/2]

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

inline

Definition at line 694 of file MooseApp.h.

694{ return _restartable_data; }

◆ getRestartableData() [2/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 693 of file MooseApp.h.

693{ return _restartable_data; }

◆ getRestartableDataMap()

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

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

Definition at line 3432 of file MooseApp.C.

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

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

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

1079{ return _restartable_meta_data.begin(); }

Referenced by SetupDebugAction::act().

◆ getRestartableDataMapEnd()

auto MooseApp::getRestartableDataMapEnd ( )

inline

Definition at line 1081 of file MooseApp.h.

1081{ return _restartable_meta_data.end(); }

Referenced by SetupDebugAction::act().

◆ getRestartableDataMapName()

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

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

Definition at line 3459 of file MooseApp.C.

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

Referenced by possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

◆ getRestartableMetaData()

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

Definition at line 2516 of file MooseApp.C.

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

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

◆ getRestartRecoverFileBase()

std::string MooseApp::getRestartRecoverFileBase ( ) const

inline

The file_base for the recovery file.

Definition at line 500 of file MooseApp.h.

500{ return _restart_recover_base; }

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

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

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

Referenced by removeRelationshipManager().

◆ getStartTime()

Real MooseApp::getStartTime ( ) const

inline

Returns: The start time

Definition at line 306 of file MooseApp.h.

306{ return _start_time; }

Referenced by TransientBase::TransientBase().

◆ getSystemInfo()

const SystemInfo & MooseApp::getSystemInfo ( ) const

inline

Get SystemInfo object.

Returns: A pointer to the SystemInformation object

Definition at line 567 of file MooseApp.h.

567{ return _sys_info; }

MooseApp::_sys_info

SystemInfo _sys_info

System Information.

Definition MooseApp.h:1340

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

◆ getVersion()

std::string MooseApp::getVersion ( ) const

virtual

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

Definition at line 1018 of file MooseApp.C.

{
  return MOOSE_VERSION;
}

Referenced by getPrintableVersion().

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns: Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

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

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

Referenced by hasInitialBackupMesh(), restoreFromInitialBackup(), and restoreMeshFromInitialBackup().

◆ hasInitialBackupMesh()

bool MooseApp::hasInitialBackupMesh ( ) const

Whether this app has an initial Backup object with mesh checkpoint entries.

Definition at line 1748 of file MooseApp.C.

{
  return hasInitialBackup() && !(*_initial_backup)->mesh_files.empty();
}

◆ hasMeshGenerator()

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

inline

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

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

282{ return _output_position_set; }

Referenced by Exodus::output().

◆ hasRecoverFileBase()

bool MooseApp::hasRecoverFileBase ( ) const

Definition at line 1698 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 2970 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 3443 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 2506 of file MooseApp.C.

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

Referenced by MeshMetaDataInterface::hasMeshProperty().

◆ hasRestartRecoverFileBase()

bool MooseApp::hasRestartRecoverFileBase ( ) const

Return true if the recovery file base is set.

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

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

Referenced by removeRelationshipManager().

◆ hasStartTime()

bool MooseApp::hasStartTime ( ) const

inline

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

Definition at line 301 of file MooseApp.h.

301{ return _start_time_set; }

Referenced by TransientBase::TransientBase().

◆ header()

std::string MooseApp::header ( ) const

virtual

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

Definition at line 2878 of file MooseApp.C.

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

Referenced by restore(), and setupOptions().

◆ isInTree()

bool MooseApp::isInTree ( )

static

Returns: Whether or not the application is in-tree

Definition at line 3623 of file MooseApp.C.

{
  return Moose::internal::Capabilities::getCapabilities({}).isInTree();
}

Referenced by isInTree().

◆ isKokkosAvailable()

bool MooseApp::isKokkosAvailable ( ) const

inline

Get whether Kokkos is available.

Returns: 1) True if MOOSE is configured with Kokkos and every process has an associated GPU, 2) True if MOOSE is configured with Kokkos and GPU capablities are disabled, 3) False otherwise.

Definition at line 1149 of file MooseApp.h.

  {
#ifdef MOOSE_KOKKOS_ENABLED
#ifdef MOOSE_ENABLE_KOKKOS_GPU
    return _has_kokkos_gpus;
#else
    return true;
#endif
#else
    return false;
#endif
  }

Referenced by MooseMesh::MooseMesh(), and MooseMesh::MooseMesh().

◆ isParamSetByUser()

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

inlineinherited

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

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), run(), runInputFile(), runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

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

Definition InputParameters.C:386

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

{
  return _recover;
}

Referenced by ExecuteMeshGenerators::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupRecoverFileBaseAction::act(), SampledOutput::cloneMesh(), MultiApp::createApp(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), MFEMSteady::execute(), FullSolveMultiApp::FullSolveMultiApp(), MooseMesh::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), Output::outputStep(), SampledOutput::outputStep(), TransientBase::preExecute(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), PhysicsBase::shouldCreateIC(), TransientMultiApp::solveStep(), and TimeExtremeValue::TimeExtremeValue().

◆ isRelocated()

bool MooseApp::isRelocated ( )

static

Returns: Whether or not the application is relocated

Definition at line 3617 of file MooseApp.C.

{
  return Moose::internal::Capabilities::getCapabilities({}).isRelocated();
}

Referenced by isRelocated().

◆ 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 \emph checkpoint restart. This will be false if doing \emph exodus restart. Finally this will never return true when isRecovering is true

Definition at line 1680 of file MooseApp.C.

{
  return _restart;
}

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

◆ isSplitMesh()

bool MooseApp::isSplitMesh ( ) const

Whether or not this is a split mesh operation.

Definition at line 1686 of file MooseApp.C.

{
  return _split_mesh;
}

Referenced by MooseMesh::init().

◆ isUltimateMaster()

bool MooseApp::isUltimateMaster ( ) const

inline

Whether or not this app is the ultimate master app.

(ie level == 0)

Definition at line 866 of file MooseApp.h.

866{ return !_multiapp_level; }

Referenced by AutoCheckpointAction::act(), ExecuteMeshGenerators::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupRecoverFileBaseAction::act(), MooseBase::callMooseError(), FEProblemBase::checkProblemIntegrity(), CopyMeshPartitioner::CopyMeshPartitioner(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), FixedPointSolve::FixedPointSolve(), MooseMesh::init(), MFEMMesh::init(), EigenProblemSolve::initialSetup(), MFEMProblemSolve::MFEMProblemSolve(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PerfGraphLivePrint::printStats(), setupOptions(), FixedPointSolve::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::~FEProblemBase().

◆ libNameToAppName()

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

Converts a library name to an application name:

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

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

Referenced by dynamicRegistration(), and loadLibraryAndDependencies().

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

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

Referenced by SetupRecoverFileBaseAction::act().

◆ markMeshChangedForBackup()

void MooseApp::markMeshChangedForBackup ( )

inline

Mark this app as requiring mesh topology data in its next Backup object.

Definition at line 755 of file MooseApp.h.

755{ _mesh_changed_for_backup = true; }

MooseApp::_mesh_changed_for_backup

bool _mesh_changed_for_backup

Whether mesh topology has changed and should be included in Backup objects.

Definition MooseApp.h:1739

Referenced by FEProblemBase::meshChanged().

◆ masterDisplacedMesh()

const MooseMesh * MooseApp::masterDisplacedMesh ( ) const

inline

Returns a pointer to the master displaced mesh.

Definition at line 881 of file MooseApp.h.

881{ return _master_displaced_mesh; }

Referenced by SetupMeshCompleteAction::act().

◆ masterMesh()

const MooseMesh * MooseApp::masterMesh ( ) const

inline

Returns a pointer to the master mesh.

Definition at line 876 of file MooseApp.h.

876{ return _master_mesh; }

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

◆ meshChangedForBackup()

bool MooseApp::meshChangedForBackup ( ) const

inline

Whether this app requires mesh topology data in its next Backup object.

Definition at line 760 of file MooseApp.h.

760{ return _mesh_changed_for_backup; }

◆ messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool hit_prefix = true ) const

inlineinherited

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

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::messagePrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

◆ messagePrefix() [2/2]

std::string MooseBase::messagePrefix	(	const InputParameters &	params,
		const bool	hit_prefix
	)

staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

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

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

Referenced by possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

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

Referenced by addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), getRecoverFileBase(), hasRecoverFileBase(), and setupOptions().

◆ mooseDeprecatedNoTrace()

template<typename... Args>

void MooseBase::mooseDeprecatedNoTrace ( Args &&... args ) const

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 277 of file MooseBase.h.

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), loadLibraryAndDependencies(), and MooseBase::paramWarning().

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ multiAppLevel()

unsigned int MooseApp::multiAppLevel ( ) const

inline

The MultiApp Level.

Returns: The current number of levels from the master app

Definition at line 855 of file MooseApp.h.

855{ return _multiapp_level; }

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

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

861{ return _multiapp_number; }

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

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

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

Referenced by runInputFile(), and setupOptions().

◆ paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 471 of file MooseBase.h.

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

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

◆ paramWarning()

template<typename... Args>

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

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

◆ parser() [1/2]

Parser & MooseApp::parser ( )

Definition at line 1891 of file MooseApp.C.

{
  return const_cast<Parser &>(std::as_const(*this).parser());
}

◆ parser() [2/2]

const Parser & MooseApp::parser ( ) const

Returns: The Parser

Definition at line 1884 of file MooseApp.C.

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

Referenced by ActionFactory::create().

◆ perfGraph()

PerfGraph & MooseApp::perfGraph ( )

inline

Get the PerfGraph for this app.

Definition at line 179 of file MooseApp.h.

179{ return _perf_graph; }

Referenced by PerfGraphInterface::perfGraph().

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

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

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

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

804{}

Referenced by restore(), and restore().

◆ preBackup()

virtual void MooseApp::preBackup ( )

inlinevirtual

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

Definition at line 770 of file MooseApp.h.

770{}

Referenced by backup(), and backup().

◆ processor_id()

processor_id_type MooseApp::processor_id ( ) const

inline

Returns the MPI processor ID of the current processor.

Definition at line 417 of file MooseApp.h.

417{ return _comm->rank(); }

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

◆ queryKokkosGPUs()

void MooseApp::queryKokkosGPUs ( )

private

Query the Kokkos GPUs in the system and check whether every process has an associated GPU.

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

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

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

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

174{ 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 1897 of file MooseApp.C.

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

Referenced by createExecutors(), and recursivelyCreateExecutors().

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

{
  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 = cast_ptr<InterfaceRegistryObjects<T> *>(it->second.get());
 
  mooseAssert(std::count(registry->_objects.begin(), registry->_objects.end(), &interface) == 0,
              "Interface already registered");
  registry->_objects.push_back(&interface);
}

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

◆ registerRestartableData() [1/2]

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

◆ registerRestartableData() [2/2]

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

Definition at line 2454 of file MooseApp.C.

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

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

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

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

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

◆ registerTimedSection() [1/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

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

Definition at line 61 of file PerfGraphInterface.C.

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

◆ registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

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

Definition at line 72 of file PerfGraphInterface.C.

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

◆ relationshipManagers()

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

inline

Return the container of relationship managers.

Definition at line 1063 of file MooseApp.h.

  {
    return _relationship_managers;
  }

Referenced by NumRelationshipManagers::getValue().

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

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

Referenced by addRelationshipManager().

◆ requestCitations()

void MooseApp::requestCitations ( )

private

Handles the –citations command-line option: registers with PETSc the BibTeX entries that should be cited for the framework and the modules/objects used in this simulation, and enables PETSc's -citations option.

PETSc prints them (together with its own and its sub-packages' citations) at PetscFinalize, to the console or to a file if one was given. The collected set spans this app and, recursively, every MultiApp subapp, and is gathered across all MPI ranks (PETSc prints from rank 0 alone), so attribution is complete for multi-app runs.

Definition at line 2141 of file MooseApp.C.

{
  // Collect the de-duplicated citations across this app and, recursively, every MultiApp subapp.
  std::map<std::string, std::string> citations;
  collectCitations(citations);
 
  // MultiApp subapps are distributed across the MPI ranks, so each rank has collected citations
  // only for the subapps it owns. PETSc prints the citation list from rank 0 alone, so gather every
  // rank's citations onto all ranks; otherwise a module used only by a subapp that lives off rank 0
  // would be omitted.
  std::vector<std::string> flattened;
  flattened.reserve(citations.size() * 2);
  for (const auto & [key, bibtex] : citations)
  {
    flattened.push_back(key);
    flattened.push_back(bibtex);
  }
  _comm->allgather(flattened);
  for (std::size_t i = 0; i + 1 < flattened.size(); i += 2)
  {
    [[maybe_unused]] const auto [it, inserted] = citations.emplace(flattened[i], flattened[i + 1]);
    mooseAssert(inserted || it->second == flattened[i + 1],
                "The same citation key was registered with different BibTeX entries");
  }
 
  // Register the resolved BibTeX entries with PETSc and enable its -citations option. PETSc prints
  // them, together with the run-specific citations from any PETSc solvers/preconditioners actually
  // used, at PetscFinalize (to the console or, if a file name was given, to that file).
  for (const auto & citation : citations)
    Moose::PetscSupport::registerPetscCitation(citation.second);
 
  Moose::PetscSupport::setSinglePetscOption("-citations", getParam<std::string>("citations"));
}

Referenced by run().

◆ restartFolderBase()

std::filesystem::path MooseApp::restartFolderBase ( const std::filesystem::path & folder_base ) const

The file suffix for restartable data.

Definition at line 3059 of file MooseApp.C.

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

Referenced by Checkpoint::output().

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

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

Referenced by restoreFromInitialBackup().

◆ 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 1774 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");
 
  if (restoreMeshBackup(*this, *backup, feProblem().mesh()))
  {
    _restored_initial_backup_mesh = true;
    feProblem().mesh().prepare();
    feProblem().meshChanged(/*intermediate_change=*/false,
                            /*contract_mesh=*/false,
                            /*clean_refinement_flags=*/false);
  }
 
  _rd_reader.setInput(std::move(header), std::move(data));
  _rd_reader.restore(filter_names);
 
  postRestore(for_restart);
}

◆ restoreDataIfAvailable()

bool MooseApp::restoreDataIfAvailable	(	RestartableDataValue &	value,
		const THREAD_ID	tid,
		Moose::PassKey< ReporterData >
	)

inline

Restores value in place from the checkpoint reader if it is present in the checkpoint and has not yet been loaded.

Used to recover data (e.g. reporter values) that is declared after the bulk restore pass while the reader window is still open. No-op on non-recover runs and for data declared before the restore window opens.

Returns: Whether or not the value was restored

Definition at line 839 of file MooseApp.h.

  {
    return _rd_reader.restoreDataIfAvailable(value, tid, {});
  }

Referenced by ReporterData::restoreReporterStateIfAvailable().

◆ restoredInitialBackupMesh()

bool MooseApp::restoredInitialBackupMesh ( ) const

inline

Whether this app has restored mesh topology from its initial Backup object.

Definition at line 750 of file MooseApp.h.

750{ return _restored_initial_backup_mesh; }

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

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

◆ restoreMeshFromInitialBackup()

void MooseApp::restoreMeshFromInitialBackup ( MooseMesh & mesh )

Restore mesh from this app's initial Backup object and consume the mesh checkpoint entries.

Definition at line 1754 of file MooseApp.C.

{
  mooseAssert(hasInitialBackup(), "Missing initial backup");
  _restored_initial_backup_mesh = restoreMeshBackup(*this, **_initial_backup, mesh);
}

◆ run()

void MooseApp::run ( )

virtual

Run the application.

Definition at line 2032 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 (Parser::Error & err)
  {
    mooseAssert(_parser->getThrowOnError(), "Should be true");
    throw;
  }
  catch (MooseRuntimeError & err)
  {
    mooseAssert(Moose::_throw_on_error, "Should be true");
    throw;
  }
  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;
  }
 
  if (isParamSetByUser("citations"))
    requestCitations();
}

Referenced by MooseServer::parseDocumentForDiagnostics().

◆ runInputFile()

void MooseApp::runInputFile ( )

virtual

Actually build everything in the input file.

Definition at line 1562 of file MooseApp.C.

{
  TIME_SECTION("runInputFile", 3);
 
  // If early exit param has been set, then just return
  if (_ready_to_exit)
    return;
 
  _action_warehouse.executeAllActions();
 
  if (isParamSetByUser("csg_only"))
  {
    _early_exit_param = "--csg-only";
    _ready_to_exit = true;
  }
  else 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());
  }
}

Referenced by run().

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

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

Referenced by run().

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

{
  _enable_unused_check = warn_is_error ? ERROR_UNUSED : WARN_UNUSED;
}

Referenced by setupOptions().

◆ setErrorOverridden()

void MooseApp::setErrorOverridden ( )

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

Definition at line 2026 of file MooseApp.C.

{
  _error_overridden = true;
}

Referenced by setupOptions().

◆ setExecutioner()

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

inline

Set the Executioner for this App.

Definition at line 349 of file MooseApp.h.

349{ _executioner = executioner; }

Referenced by CreateExecutionerAction::act().

◆ setExecutor()

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

inline

Definition at line 350 of file MooseApp.h.

350{ _executor = executor; }

◆ setExitCode()

void MooseApp::setExitCode ( const int exit_code )

inline

Sets the exit code that the application will exit with.

Definition at line 168 of file MooseApp.h.

168{ _exit_code = exit_code; }

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

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

430{ _initial_from_file = flag; }

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

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

  {
    _ex_reader = exreader;
  }

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

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

312{ _global_time_offset = offset; }

◆ setMFEMDevice()

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

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

{
  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->SetGPUAwareMPI(mfem::GetEnv("MFEM_GPU_AWARE_MPI") ? true : gpu_aware_mpi);
    _mfem_device->Print(Moose::out);
  }
  else if (!device_string.empty() && 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, " "),
               "'");
}

Referenced by MFEMProblemSolve::MFEMProblemSolve().

◆ 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 1546 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 540 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 2351 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 2890 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 2884 of file MooseApp.C.

{
  _restart = value;
}

Referenced by FEProblemBase::setRestartFile().

◆ setRestartRecoverFileBase()

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

inline

mutator for recover_base (set by RecoverBaseAction)

Definition at line 512 of file MooseApp.h.

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

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

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

{
  _start_time_set = true;
  _start_time = time;
}

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

◆ setupOptions()

void MooseApp::setupOptions ( )

virtual

Setup options based on InputParameters.

Definition at line 1030 of file MooseApp.C.

{
  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();
 
  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
 
  // Capability checking
  {
    // Augment capabilities from the TestHarness
    std::optional<std::set<std::string>> ignore_capabilities;
    if (isParamValid("testharness_capabilities"))
    {
      if (!isParamValid("required_capabilities"))
        mooseError(
            "--testharness-capabilities: Should not be specified without --required-capabilities");
 
      const auto file_path = std::filesystem::absolute(
          std::filesystem::path(getParam<std::string>("testharness_capabilities")));
 
      std::ifstream file(file_path);
      if (!file)
        mooseError("--testharness-capabilities: Could not open ", file_path);
 
      nlohmann::json root;
      try
      {
        file >> root;
        if (const auto it = root.find("capabilities"); it != root.end())
          Moose::internal::Capabilities::getCapabilities({}).augment(*it, {});
        if (const auto it = root.find("ignore_capabilities"); it != root.end())
          ignore_capabilities = it->get<std::set<std::string>>();
      }
      catch (const std::exception & e)
      {
        mooseError(
            "--testharness-capabilities: Failed to load capabilities ", file_path, ":\n", e.what());
      }
    }
 
    if (isParamValid("required_capabilities"))
    {
      using Moose::internal::CapabilityRegistry;
 
      const auto & required_capabilities = getParam<std::string>("required_capabilities");
 
      CapabilityRegistry::CheckOptions options;
      // Allowed to be unknown
      options.certain = false;
      // Add ignored capabilities, if any
      if (ignore_capabilities)
        options.ignore_capabilities = *ignore_capabilities;
 
      CapabilityRegistry::CheckResult result;
      try
      {
        result = Moose::internal::Capabilities::getCapabilities({}).check(required_capabilities,
                                                                          options);
      }
      catch (const std::exception & e)
      {
        mooseError("--required-capablities: ", e.what());
      }
 
      if (result.state < CapabilityRegistry::CheckState::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 (result.state == CapabilityRegistry::CheckState::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'");
    }
  }
 
  // 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>("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::internal::Capabilities::getCapabilities({}).dump());
    _ready_to_exit = true;
  }
  else if (isParamValid("check_capabilities"))
  {
    using Moose::internal::CapabilityRegistry;
 
    _perf_graph.disableLivePrint();
    const auto & capabilities = getParam<std::string>("check_capabilities");
 
    CapabilityRegistry::CheckResult result;
    try
    {
      result = Moose::internal::Capabilities::getCapabilities({}).check(capabilities);
    }
    catch (const std::exception & e)
    {
      mooseError("--check-capablities: ", e.what());
    }
 
    const bool pass = result.state == CapabilityRegistry::CheckState::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;
    }
 
    _builder.build();
 
    // 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 = {
        "csg_only", "mesh_only", "split_mesh", "parse_neml2_only"};
    if (isExclusiveParamSetByUser(final_task_params, "csg_only"))
    {
      // Error checking on incompatible command line options
      if (_distributed_mesh_on_command_line)
        mooseError("--csg-only cannot be used in conjunction with --distributed-mesh");
      const bool has_mesh_split = isParamSetByUser("split_file") || _use_split;
      if (has_mesh_split)
        mooseError("--csg-only is not compatible with any mesh splitting options");
      if (isParamSetByUser("refinements"))
        mooseError("--csg-only cannot be used in conjunction with -r refinements option");
      if (!isUltimateMaster())
        mooseError("--csg-only option cannot be used as a Subapp");
      if (_recover)
        mooseError("--csg-only option cannot be used in recovery mode");
 
      _syntax.registerTaskName("execute_csg_generators", true);
      _syntax.addDependency("execute_csg_generators", "execute_mesh_generators");
      _syntax.addDependency("recover_meta_data", "execute_csg_generators");
 
      _syntax.registerTaskName("csg_only", true);
      _syntax.addDependency("csg_only", "recover_meta_data");
      _syntax.addDependency("set_mesh_base", "csg_only");
      _action_warehouse.setFinalTask("csg_only");
    }
    else 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;
}

Referenced by run().

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

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

Referenced by run().

◆ solutionInvalidity() [1/2]

SolutionInvalidity & MooseApp::solutionInvalidity ( )

inline

Get the SolutionInvalidity for this app.

Definition at line 185 of file MooseApp.h.

185{ return _solution_invalidity; }

Referenced by FEProblemBase::acceptInvalidSolution(), SolverSystem::checkInvalidSolution(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeJacobianSys(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeResidualSys(), NonlinearSystem::converged(), SolutionInvalidInterface::flagInvalidSolutionInternal(), FEProblemSolve::initialSetup(), SolutionInvalidityReporter::SolutionInvalidityReporter(), and FixedPointSolve::solveStep().

◆ solutionInvalidity() [2/2]

const SolutionInvalidity & MooseApp::solutionInvalidity ( ) const

inline

Definition at line 186 of file MooseApp.h.

186{ return _solution_invalidity; }

◆ syntax()

Syntax & MooseApp::syntax ( )

inline

Returns a writable reference to the syntax object.

Definition at line 231 of file MooseApp.h.

231{ return _syntax; }

Referenced by MooseServer::addSubblocksToList(), MooseServer::addValuesToList(), dynamicAllRegistration(), MooseServer::gatherDocumentReferencesLocations(), MooseServer::getActionParameters(), MooseServer::getCompletionItemKind(), MooseServer::getHoverDisplayText(), MooseServer::getInputLookupDefinitionNodes(), MooseServer::getObjectParameters(), and setupOptions().

◆ testCheckpointHalfTransient()

bool MooseApp::testCheckpointHalfTransient ( ) const

inline

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

Definition at line 524 of file MooseApp.h.

524{ return _test_checkpoint_half_transient; }

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

◆ testReStep()

bool MooseApp::testReStep ( ) const

inline

Whether or not this simulation should fail a timestep and repeat (for testing).

Selection rules for which time step to fail in TransientBase.C constructor.

Definition at line 530 of file MooseApp.h.

530{ return _test_restep; }

Referenced by Control::Control(), Executioner::Executioner(), Executioner::Executioner(), and TransientBase::TransientBase().

◆ theWarehouse()

TheWarehouse & MooseApp::theWarehouse ( )

inline

Definition at line 143 of file MooseApp.h.

143{ return *_the_warehouse; }

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

◆ timedSectionName()

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

protectedinherited

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

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

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

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

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

Definition at line 57 of file MooseBase.C.

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

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

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

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

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

◆ uniqueParameterName()

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

inherited

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

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

◆ unusedFlagIsError()

bool MooseApp::unusedFlagIsError ( ) const

inline

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

Definition at line 1120 of file MooseApp.h.

1120{ return _enable_unused_check == ERROR_UNUSED; }

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

◆ unusedFlagIsWarning()

bool MooseApp::unusedFlagIsWarning ( ) const

inline

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

Definition at line 1117 of file MooseApp.h.

1117{ return _enable_unused_check == WARN_UNUSED; }

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

◆ useEigenvalue()

bool & MooseApp::useEigenvalue ( )

inline

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

Definition at line 402 of file MooseApp.h.

402{ return _use_eigen_value; }

Referenced by CreateProblemDefaultAction::act().

◆ useExecutor()

bool MooseApp::useExecutor ( ) const

inline

Definition at line 343 of file MooseApp.h.

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

871{ return _use_master_mesh; }

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

◆ useNonlinear()

bool & MooseApp::useNonlinear ( )

inline

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

Definition at line 397 of file MooseApp.h.

397{ return _use_nonlinear; }

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

◆ validParams()

InputParameters MooseApp::validParams ( )

static

Definition at line 275 of file MooseApp.C.

{
  InputParameters params = MooseBase::validParams();
 
  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.addOptionalValuedCommandLineParam<std::string>(
      "csg_only",
      "--csg-only <optional path>",
      "",
      "Setup and output the input mesh in CSG format only (Default: "
      "\"<input_file_name>_out_csg.json\")");
  params.addCommandLineParam<bool>(
      "show_actions",
      "--show-actions",
      "Shows the list of Actions as they execute, in order of execution");
  params.setGlobalCommandLineParam("show_actions");
  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>("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>(
      "testharness_capabilities",
      "--testharness-capabilities",
      "Path to JSON from the TestHarness that contains capabilities to be appended.");
 
  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.addOptionalValuedCommandLineParam<std::string>(
      "citations",
      "--citations [file]",
      "",
      "List the papers (in BibTeX format) that should be cited for the framework, PETSc, and the "
      "modules and objects used in this simulation; optionally write them to [file] instead of the "
      "console");
 
  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>("test_restep",
                                   "--test-restep",
                                   "Test re-running the middle timestep; used by the TestHarness");
 
  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");
 
  const MooseEnum compute_device_type("cpu cuda mps hip ceed-cpu ceed-cuda ceed-hip xpu", "cpu");
  params.addCommandLineParam<MooseEnum>(
      "compute_device",
      "--compute-device",
      compute_device_type,
      "The device type we want to run accelerated (libtorch, MFEM) computations 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::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::set<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);
 
  params.registerBase("Application");
 
  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 2557 of file MooseApp.C.

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

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

◆ 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 2571 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 Symbol Documentation

◆ FEProblemBase

friend class FEProblemBase

friend

Definition at line 1755 of file MooseApp.h.

◆ Restartable

friend class Restartable

friend

Definition at line 1756 of file MooseApp.h.

◆ SubProblem

friend class SubProblem

friend

Definition at line 1757 of file MooseApp.h.

Member Data Documentation

◆ _action_factory

ActionFactory MooseApp::_action_factory

protected

The Factory responsible for building Actions.

Definition at line 1325 of file MooseApp.h.

Referenced by createMinimalApp(), and getActionFactory().

◆ _action_warehouse

ActionWarehouse MooseApp::_action_warehouse

protected

Where built actions are stored.

Definition at line 1328 of file MooseApp.h.

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

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by MooseBase::callMooseError(), MooseBase::connectControllableParams(), and MooseBase::getMooseApp().

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

Referenced by attachRelationshipManagers(), and attachRelationshipManagers().

◆ _automatic_automatic_scaling

const bool MooseApp::_automatic_automatic_scaling

private

Whether to turn on automatic scaling by default.

Definition at line 1712 of file MooseApp.h.

Referenced by defaultAutomaticScaling().

◆ _builder

Moose::Builder MooseApp::_builder

protected

Builder for building app related parser tree.

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

Referenced by getChainControlDataSystem().

◆ _check_input

const bool MooseApp::_check_input

protected

true if we want to just check the input file

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

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

◆ _command_line

const std::shared_ptr<CommandLine> MooseApp::_command_line

protected

The CommandLine object.

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

◆ _cpu_profiling

bool MooseApp::_cpu_profiling = false

private

CPU profiling.

Definition at line 1715 of file MooseApp.h.

◆ _distributed_mesh_on_command_line

const 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 1419 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 1407 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 1405 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 1416 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 1706 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 1364 of file MooseApp.h.

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

◆ _executor

std::shared_ptr<Executor> MooseApp::_executor

protected

Pointer to the Executor of this run.

Definition at line 1367 of file MooseApp.h.

Referenced by attachRelationshipManagers(), collectCitations(), 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 1375 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 1370 of file MooseApp.h.

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

◆ _exit_code

int MooseApp::_exit_code

protected

The exit code.

Definition at line 1410 of file MooseApp.h.

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

◆ _factory

Factory MooseApp::_factory

protected

Definition at line 1402 of file MooseApp.h.

Referenced by addExecutor(), collectCitations(), 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 1300 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 1379 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 1434 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 1315 of file MooseApp.h.

Referenced by getGlobalTimeOffset(), and setGlobalTimeOffset().

◆ _has_kokkos_gpus

bool MooseApp::_has_kokkos_gpus = false

private

Flag whether every process has an associated Kokkos GPU.

Definition at line 1773 of file MooseApp.h.

Referenced by isKokkosAvailable().

◆ _heap_profiling

bool MooseApp::_heap_profiling = false

private

Memory profiling.

Definition at line 1718 of file MooseApp.h.

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

Referenced by hasInitialBackup(), restoreFromInitialBackup(), and restoreMeshFromInitialBackup().

◆ _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 1413 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 1322 of file MooseApp.h.

Referenced by getInputParameterWarehouse().

◆ _interface_registry

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

private

Registration for interface objects.

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

Referenced by getLoadedLibraryPaths(), and loadLibraryAndDependencies().

◆ _libtorch_device

const torch::DeviceType MooseApp::_libtorch_device

private

The libtorch device this app is using (converted from compute_device)

Definition at line 1743 of file MooseApp.h.

Referenced by getLibtorchDevice().

◆ _master_displaced_mesh

const MooseMesh* const MooseApp::_master_displaced_mesh

private

The displaced mesh from master app.

Definition at line 1689 of file MooseApp.h.

Referenced by masterDisplacedMesh().

◆ _master_mesh

const MooseMesh* const MooseApp::_master_mesh

private

The mesh from master app.

Definition at line 1686 of file MooseApp.h.

Referenced by masterMesh().

◆ _mesh_changed_for_backup

bool MooseApp::_mesh_changed_for_backup = false

private

Whether mesh topology has changed and should be included in Backup objects.

Definition at line 1739 of file MooseApp.h.

Referenced by markMeshChangedForBackup(), and meshChangedForBackup().

◆ _mesh_generator_system

MeshGeneratorSystem MooseApp::_mesh_generator_system

private

The system that manages the MeshGenerators.

Definition at line 1692 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 1748 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 1751 of file MooseApp.h.

Referenced by getMFEMDevices(), and setMFEMDevice().

◆ _multiapp_level

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

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

◆ _multiapp_number

const unsigned int MooseApp::_multiapp_number

private

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

Definition at line 1680 of file MooseApp.h.

Referenced by multiAppNumber().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _null_executor

std::shared_ptr<NullExecutor> MooseApp::_null_executor

protected

Used to return an executor that does nothing.

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

Referenced by setupOptions().

◆ _output_file_base

std::string MooseApp::_output_file_base

protected

The output file basename.

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

Referenced by getOutputFileNumbers(), and setOutputFileNumbers().

◆ _output_position

Point MooseApp::_output_position

protected

The output position.

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

Referenced by hasOutputPosition(), and setOutputPosition().

◆ _output_warehouse

OutputWarehouse MooseApp::_output_warehouse

protected

OutputWarehouse object for this App.

Definition at line 1331 of file MooseApp.h.

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

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), showInputs(), and MooseBase::uniqueName().

◆ _parser

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

protected

Parser for parsing the input file (owns the root hit node)

Definition at line 1334 of file MooseApp.h.

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

◆ _perf_graph

PerfGraph& MooseApp::_perf_graph

protected

The PerfGraph object for this application (recoverable)

Definition at line 1355 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 135 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 138 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 1361 of file MooseApp.h.

Referenced by rankMap().

◆ _rd_reader

RestartableDataReader MooseApp::_rd_reader

private

Definition at line 1697 of file MooseApp.h.

Referenced by finalizeRestore(), restore(), restore(), and restoreDataIfAvailable().

◆ _ready_to_exit

bool MooseApp::_ready_to_exit

protected

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

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

◆ _restart

bool MooseApp::_restart

protected

Whether or not this is a restart run.

Definition at line 1425 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 1440 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 1346 of file MooseApp.h.

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

◆ _restartable_meta_data

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

private

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

Definition at line 1664 of file MooseApp.h.

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

◆ _restored_initial_backup_mesh

bool MooseApp::_restored_initial_backup_mesh = false

private

Whether mesh topology has been restored from the initial Backup object.

Definition at line 1736 of file MooseApp.h.

Referenced by restore(), restoredInitialBackupMesh(), and restoreMeshFromInitialBackup().

◆ _solution_invalidity

SolutionInvalidity& MooseApp::_solution_invalidity

protected

The SolutionInvalidity object for this application.

Definition at line 1358 of file MooseApp.h.

Referenced by solutionInvalidity(), and solutionInvalidity().

◆ _split_mesh

bool MooseApp::_split_mesh

protected

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

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

Referenced by hasStartTime(), and setStartTime().

◆ _syntax

Syntax MooseApp::_syntax

protected

Syntax of the input file.

Definition at line 1318 of file MooseApp.h.

Referenced by setupOptions(), and syntax().

◆ _sys_info

SystemInfo MooseApp::_sys_info

protected

System Information.

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

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

◆ _test_checkpoint_half_transient

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

Referenced by testCheckpointHalfTransient().

◆ _test_restep

const bool MooseApp::_test_restep

protected

Whether or not this simulation should fail its middle timestep and repeat (for testing)

Definition at line 1445 of file MooseApp.h.

Referenced by testReStep().

◆ _the_warehouse

std::unique_ptr<TheWarehouse> MooseApp::_the_warehouse

private

The combined warehouse for storing any MooseObject based object.

Definition at line 1674 of file MooseApp.h.

Referenced by theWarehouse().

◆ _trap_fpe

bool MooseApp::_trap_fpe

protected

Whether or not FPE trapping should be turned on.

Definition at line 1437 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 1291 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 1465 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 1392 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 1383 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 1683 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 1389 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 1431 of file MooseApp.h.

Referenced by setupOptions().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ MESH_META_DATA

const RestartableDataMapName MooseApp::MESH_META_DATA = "MeshMetaData"

static

Definition at line 136 of file MooseApp.h.

Referenced by MeshOnlyAction::act(), SetupDebugAction::act(), SplitMeshAction::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 137 of file MooseApp.h.

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

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

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ RegistrationType

◆ UNUSED_CHECK

Constructor & Destructor Documentation

◆ ~MooseApp()

◆ MooseApp()

Member Function Documentation

◆ actionWarehouse() [1/2]

◆ actionWarehouse() [2/2]

◆ addAppParam()

◆ addBoolCapability()

◆ addCapability()

◆ addCapabilityInternal()

◆ addExecutor()

◆ addExecutorParams()

◆ addInputParam()

◆ addIntCapability()

◆ addMeshGenerator()

◆ addRelationshipManager()

◆ addStringCapability()

◆ allocateKokkosMemoryPool()

◆ appBinaryName()

◆ appendMeshGenerator()

◆ appNameToLibName()

◆ attachRelationshipManagers() [1/2]

◆ attachRelationshipManagers() [2/2]

◆ backup() [1/2]

◆ backup() [2/2]

◆ builder()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkInput()

◆ checkMetaDataIntegrity()

◆ checkpointSuffix()

◆ collectCitations()

◆ commandLine()

◆ connectControllableParams()

◆ constructingMeshGenerators()

◆ copyInputs()

◆ createExecutors()

◆ createMinimalApp()

◆ createRecoverablePerfGraph()

◆ createRecoverableSolutionInvalidity()

◆ createRMFromTemplateAndInit()

◆ deallocateKokkosMemoryPool()

◆ defaultAutomaticScaling()

◆ determineLibtorchDeviceType()

◆ disableCheckUnusedFlag()

◆ dynamicAllRegistration()

◆ dynamicAppRegistration()

◆ dynamicRegistration()

◆ errorCheck()

◆ errorOnJacobianNonzeroReallocation()

◆ errorPrefix()

◆ executeExecutioner()

◆ exitCode()

◆ feProblem()

◆ finalizeRestore()

◆ fixedPointConfig()

◆ forceRestart()

◆ FRIEND_TEST() [1/4]

◆ FRIEND_TEST() [2/4]

◆ FRIEND_TEST() [3/4]

◆ FRIEND_TEST() [4/4]

◆ getActionFactory()