https://mooseframework.inl.gov
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
MooseApp Class Reference

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

#include <MooseApp.h>

Inheritance diagram for MooseApp:
[legend]

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

Static Public Member Functions

static InputParameters validParams ()
 
static const std::string & checkpointSuffix ()
 The file suffix for the checkpoint mesh. More...
 
static std::filesystem::path metaDataFolderBase (const std::filesystem::path &folder_base, const std::string &map_suffix)
 The file suffix for meta data (header and data) More...
 
static void addAppParam (InputParameters &params)
 
static void addInputParam (InputParameters &params)
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node)
 External method for calling moose error with added object context. More...
 

Public Attributes

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

Static Public Attributes

static const RestartableDataMapName MESH_META_DATA = "MeshMetaData"
 
static const std::string MESH_META_DATA_SUFFIX = "mesh"
 
static const std::string type_param = "_type"
 The name of the parameter that contains the object type. More...
 
static const std::string name_param = "_object_name"
 The name of the parameter that contains the object name. More...
 
static const std::string unique_name_param = "_unique_name"
 The name of the parameter that contains the unique object name. More...
 
static const std::string app_param = "_moose_app"
 The name of the parameter that contains the MooseApp. More...
 
static const std::string moose_base_param = "_moose_base"
 The name of the parameter that contains the moose system base. More...
 
static const std::string kokkos_object_param = "_kokkos_object"
 The name of the parameter that indicates an object is a Kokkos functor. More...
 

Protected Types

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

Protected Member Functions

void dynamicRegistration (const libMesh::Parameters &params)
 Helper method for dynamic loading of objects. More...
 
void loadLibraryAndDependencies (const std::string &library_filename, const libMesh::Parameters &params, bool load_dependencies=true)
 Recursively loads libraries and dependencies in the proper order to fully register a MOOSE application that may have several dependencies. More...
 
 MooseApp (const InputParameters &parameters)
 Constructor is protected so that this object is constructed through the AppFactory object. More...
 
void registerRestartableNameWithFilter (const std::string &name, Moose::RESTARTABLE_FILTER filter)
 NOTE: This is an internal function meant for MOOSE use only! More...
 
void errorCheck ()
 Runs post-initialization error checking that cannot be run correctly unless the simulation has been fully set up and initialized. More...
 
void outputMachineReadableData (const std::string &param, const std::string &start_marker, const std::string &end_marker, const std::string &data) const
 Outputs machine readable data (JSON, YAML, etc.) either to the screen (if no filename was provided as an argument to the parameter param) or to a file (if a filename was provided). More...
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 Call to register a named section for timing. More...
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 Call to register a named section for timing. More...
 
std::string timedSectionName (const std::string &section_name) const
 

Static Protected Member Functions

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

Protected Attributes

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

Private Types

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

Private Member Functions

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

Static Private Member Functions

static void checkReservedCapability (const std::string &capability)
 Helper that reports an error if the given capability is reserved and should not be added via addCapability(). More...
 

Private Attributes

std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
 General storage for custom RestartableData that can be added to from outside applications. More...
 
std::unique_ptr< TheWarehouse > _the_warehouse
 The combined warehouse for storing any MooseObject based object. More...
 
unsigned int _multiapp_level
 Level of multiapp, the master is level 0. This used by the Console to indent output. More...
 
unsigned int _multiapp_number
 Numbering in all the sub-apps on the same level. More...
 
const bool _use_master_mesh
 Whether to use the parent app mesh for this app. More...
 
const MooseMesh *const _master_mesh
 The mesh from master app. More...
 
const MooseMesh *const _master_displaced_mesh
 The displaced mesh from master app. More...
 
MeshGeneratorSystem _mesh_generator_system
 The system that manages the MeshGenerators. More...
 
ChainControlDataSystem _chain_control_system
 The system that manages the ChainControls. More...
 
RestartableDataReader _rd_reader
 
const ExecFlagEnum _execute_flags
 Execution flags for this App. More...
 
std::streambuf * _output_buffer_cache
 Cache output buffer so the language server can turn it off then back on. More...
 
const bool _automatic_automatic_scaling
 Whether to turn on automatic scaling by default. More...
 
bool _cpu_profiling = false
 CPU profiling. More...
 
bool _heap_profiling = false
 Memory profiling. More...
 
std::map< const RelationshipManager *, std::map< const MeshBase *, std::unique_ptr< RelationshipManager > > > _template_to_clones
 Map from a template relationship manager to a map in which the key-value pairs represent the MeshBase object and the clone of the template relationship manager, e.g. More...
 
std::map< std::type_index, std::unique_ptr< InterfaceRegistryObjectsBase > > _interface_registry
 Registration for interface objects. More...
 
std::unique_ptr< Backup > *const _initial_backup
 The backup for use in initial setup; this will get set from the _initial_backup input parameter that typically gets set from a MultiApp that has a backup This is a pointer to a pointer because at the time of construction of the app, the backup will not be filled yet. More...
 
const torch::DeviceType _libtorch_device
 The libtorch device this app is using (converted from compute_device) More...
 
std::shared_ptr< mfem::Device > _mfem_device
 The MFEM Device object. More...
 
std::set< std::string > _mfem_devices
 MFEM supported devices based on user-provided config. More...
 
bool _has_kokkos_gpus = false
 Flag whether every process has an associated Kokkos GPU. More...
 
bool _has_kokkos_objects = false
 Flag whether there is any Kokkos object added by actions. More...
 

Friends

class FEProblemBase
 
class Restartable
 
class SubProblem
 

Detailed Description

Base class for MOOSE-based applications.

This generic class for application provides:

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

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

1546  {
1547  APPLICATION,
1548  REGALL
1549  };

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

1292  {
1293  OFF,
1294  WARN_UNUSED,
1295  ERROR_UNUSED
1296  } _enable_unused_check;
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check

Constructor & Destructor Documentation

◆ ~MooseApp()

MooseApp::~MooseApp ( )
virtual

Definition at line 1213 of file MooseApp.C.

1214 {
1215 #ifdef HAVE_GPERFTOOLS
1216  // CPU profiling stop
1217  if (_cpu_profiling)
1218  ProfilerStop();
1219  // Heap profiling stop
1220  if (_heap_profiling)
1221  HeapProfilerStop();
1222 #endif
1223  _action_warehouse.clear();
1224  _the_warehouse.reset();
1225  _executioner.reset();
1226 
1227  // Don't wait for implicit destruction of input parameter storage
1228  _input_parameter_warehouse.reset();
1229 
1230  // This is dirty, but I don't know what else to do. Obviously, others
1231  // have had similar problems if you look above. In specific, the
1232  // dlclose below on macs is destructing some data that does not
1233  // belong to it in garbage collection. So... don't even give
1234  // dlclose an option
1235  _restartable_data.clear();
1236 
1237  // Remove this app's parameters from the AppFactory. This allows
1238  // for creating an app with this name again in the same execution,
1239  // which needs to be done when resetting applications in MultiApp
1240  AppFactory::instance().clearAppParams(parameters(), {});
1241 
1242 #ifdef LIBMESH_HAVE_DLOPEN
1243  // Close any open dynamic libraries
1244  for (const auto & lib_pair : _lib_handles)
1245  dlclose(lib_pair.second.library_handle);
1246 #endif
1247 
1248 #ifdef MOOSE_KOKKOS_ENABLED
1249  deallocateKokkosMemoryPool();
1250 #endif
1251 }
MooseApp::_the_warehouse
std::unique_ptr< TheWarehouse > _the_warehouse
The combined warehouse for storing any MooseObject based object.
Definition: MooseApp.h:1552
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
MooseApp::deallocateKokkosMemoryPool
void deallocateKokkosMemoryPool()
Deallocate Kokkos memory pool.
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242
AppFactory::clearAppParams
void clearAppParams(const InputParameters &params, const ClearAppParamsKey)
Clears the stored parameters for the given application parameteres.
Definition: AppFactory.C:51
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseApp::_heap_profiling
bool _heap_profiling
Memory profiling.
Definition: MooseApp.h:1596
MooseApp::_lib_handles
std::unordered_map< std::string, DynamicLibraryInfo > _lib_handles
The library archive (name only), registration method and the handle to the method.
Definition: MooseApp.h:1371
AppFactory::instance
static AppFactory & instance()
Get the instance of the AppFactory.
Definition: AppFactory.C:18
MooseApp::_cpu_profiling
bool _cpu_profiling
CPU profiling.
Definition: MooseApp.h:1593
MooseApp::_input_parameter_warehouse
std::unique_ptr< InputParameterWarehouse > _input_parameter_warehouse
Input parameter storage structure; unique_ptr so we can control its destruction order.
Definition: MooseApp.h:1218
ActionWarehouse::clear
void clear()
This method deletes all of the Actions in the warehouse.
Definition: ActionWarehouse.C:61

◆ MooseApp()

MooseApp::MooseApp ( const InputParameters &  parameters)
protected

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

Definition at line 443 of file MooseApp.C.

444  : PerfGraphInterface(*this, "MooseApp"),
445  ParallelObject(*parameters.get<std::shared_ptr<Parallel::Communicator>>(
446  "_comm")), // Can't call getParam() before pars is set
447  // The use of AppFactory::getAppParams() is atrocious. However, a long time ago
448  // we decided to copy construct parameters in each derived application...
449  // which means that the "parameters" we get if someone derives from MooseApp are
450  // actually a copy of the ones built by the factory. Because we have unique
451  // application names, this allows us to reference (using _pars and MooseBase)
452  // the actual const parameters that the AppFactory made for this application
453  MooseBase(*this, AppFactory::instance().getAppParams(parameters)),
454  _comm(getParam<std::shared_ptr<Parallel::Communicator>>("_comm")),
455  _file_base_set_by_user(false),
456  _output_position_set(false),
457  _start_time_set(false),
458  _start_time(0.0),
459  _global_time_offset(0.0),
460  _input_parameter_warehouse(std::make_unique<InputParameterWarehouse>()),
461  _action_factory(*this),
462  _action_warehouse(*this, _syntax, _action_factory),
463  _output_warehouse(*this),
464  _parser(getCheckedPointerParam<std::shared_ptr<Parser>>("_parser")),
465  _command_line(getCheckedPointerParam<std::shared_ptr<CommandLine>>("_command_line")),
466  _builder(*this, _action_warehouse, *_parser),
467  _restartable_data(libMesh::n_threads()),
468  _perf_graph(createRecoverablePerfGraph()),
469  _solution_invalidity(createRecoverableSolutionInvalidity()),
470  _rank_map(*_comm, _perf_graph),
471  _use_executor(getParam<bool>("use_executor")),
472  _null_executor(NULL),
473  _use_nonlinear(true),
474  _use_eigen_value(false),
475  _enable_unused_check(ERROR_UNUSED),
476  _factory(*this),
477  _error_overridden(false),
478  _early_exit_param(""),
479  _ready_to_exit(false),
480  _exit_code(0),
481  _initial_from_file(false),
482  _distributed_mesh_on_command_line(false),
483  _recover(false),
484  _restart(false),
485  _split_mesh(false),
486  _use_split(getParam<bool>("use_split")),
487  _force_restart(getParam<bool>("force_restart")),
488 #ifdef DEBUG
489  _trap_fpe(true),
490 #else
491  _trap_fpe(false),
492 #endif
493  _test_checkpoint_half_transient(parameters.get<bool>("test_checkpoint_half_transient")),
494  _test_restep(parameters.get<bool>("test_restep")),
495  _check_input(getParam<bool>("check_input")),
496  _multiapp_level(isParamValid("_multiapp_level") ? getParam<unsigned int>("_multiapp_level")
497  : 0),
498  _multiapp_number(isParamValid("_multiapp_number") ? getParam<unsigned int>("_multiapp_number")
499  : 0),
500  _use_master_mesh(getParam<bool>("_use_master_mesh")),
501  _master_mesh(isParamValid("_master_mesh") ? getParam<const MooseMesh *>("_master_mesh")
502  : nullptr),
503  _master_displaced_mesh(isParamValid("_master_displaced_mesh")
504  ? getParam<const MooseMesh *>("_master_displaced_mesh")
505  : nullptr),
506  _mesh_generator_system(*this),
507  _chain_control_system(*this),
508  _rd_reader(*this, _restartable_data, forceRestart()),
509  _execute_flags(moose::internal::ExecFlagRegistry::getExecFlagRegistry().getFlags()),
510  _output_buffer_cache(nullptr),
511  _automatic_automatic_scaling(getParam<bool>("automatic_automatic_scaling")),
512  _initial_backup(getParam<std::unique_ptr<Backup> *>("_initial_backup"))
513 #ifdef MOOSE_LIBTORCH_ENABLED
514  ,
515  _libtorch_device(determineLibtorchDeviceType(getParam<MooseEnum>("compute_device")))
516 #endif
517 #ifdef MOOSE_MFEM_ENABLED
518  ,
519  _mfem_device(isParamValid("_mfem_device")
520  ? getParam<std::shared_ptr<mfem::Device>>("_mfem_device")
521  : nullptr),
522  _mfem_devices(isParamValid("_mfem_devices") ? getParam<std::set<std::string>>("_mfem_devices")
523  : std::set<std::string>{})
524 #endif
525 {
526  if (&parameters != &_pars)
527  {
528  const auto show_trace = Moose::show_trace;
529  Moose::show_trace = false;
530  const std::string bad_params = "(InputParameters parameters)";
531  const std::string good_params = "(const InputParameters & parameters)";
532  const std::string source_constructor = type() + "::" + type();
533  mooseDoOnce(mooseDeprecated(type(),
534  " copy-constructs its input parameters.\n\n",
535  "This is deprecated and will not be allowed in the future.\n\n",
536  "In ",
537  type(),
538  ".C, change:\n ",
539  source_constructor,
540  bad_params,
541  " -> ",
542  source_constructor,
543  good_params,
544  "\n\n",
545  "In ",
546  type(),
547  ".h, change:\n ",
548  type(),
549  bad_params,
550  "; -> ",
551  type(),
552  good_params,
553  ";"));
554  Moose::show_trace = show_trace;
555  }
556 
557  mooseAssert(_command_line->hasParsed(), "Command line has not parsed");
558  mooseAssert(_parser->queryRoot() && _parser->queryCommandLineRoot(), "Parser has not parsed");
559 
560  // Set the TIMPI sync type via --timpi-sync
561  const auto & timpi_sync = getParam<std::string>("timpi_sync");
562  const_cast<Parallel::Communicator &>(comm()).sync_type(timpi_sync);
563 
564 #ifdef HAVE_GPERFTOOLS
565  if (isUltimateMaster())
566  {
567  bool has_cpu_profiling = false;
568  bool has_heap_profiling = false;
569  static std::string cpu_profile_file;
570  static std::string heap_profile_file;
571 
572  // For CPU profiling, users need to have environment 'MOOSE_PROFILE_BASE'
573  if (std::getenv("MOOSE_PROFILE_BASE"))
574  {
575  has_cpu_profiling = true;
576  cpu_profile_file =
577  std::getenv("MOOSE_PROFILE_BASE") + std::to_string(_comm->rank()) + ".prof";
578  // create directory if needed
579  auto name = MooseUtils::splitFileName(cpu_profile_file);
580  if (!name.first.empty())
581  {
582  if (processor_id() == 0)
583  MooseUtils::makedirs(name.first.c_str());
584  _comm->barrier();
585  }
586  }
587 
588  // For Heap profiling, users need to have 'MOOSE_HEAP_BASE'
589  if (std::getenv("MOOSE_HEAP_BASE"))
590  {
591  has_heap_profiling = true;
592  heap_profile_file = std::getenv("MOOSE_HEAP_BASE") + std::to_string(_comm->rank());
593  // create directory if needed
594  auto name = MooseUtils::splitFileName(heap_profile_file);
595  if (!name.first.empty())
596  {
597  if (processor_id() == 0)
598  MooseUtils::makedirs(name.first.c_str());
599  _comm->barrier();
600  }
601  }
602 
603  // turn on profiling only on selected ranks
604  if (isParamSetByUser("gperf_profiler_on"))
605  {
606  auto rankstr = getParam<std::string>("gperf_profiler_on");
607  std::vector<processor_id_type> ranks;
608  bool success = MooseUtils::tokenizeAndConvert(rankstr, ranks, ", ");
609  if (!success)
610  mooseError("Invalid argument for --gperf-profiler-on: '", rankstr, "'");
611  for (auto & rank : ranks)
612  {
613  if (rank >= _comm->size())
614  mooseError("Invalid argument for --gperf-profiler-on: ",
615  rank,
616  " is greater than or equal to ",
617  _comm->size());
618  if (rank == _comm->rank())
619  {
620  _cpu_profiling = has_cpu_profiling;
621  _heap_profiling = has_heap_profiling;
622  }
623  }
624  }
625  else
626  {
627  _cpu_profiling = has_cpu_profiling;
628  _heap_profiling = has_heap_profiling;
629  }
630 
631  if (_cpu_profiling)
632  if (!ProfilerStart(cpu_profile_file.c_str()))
633  mooseError("CPU profiler is not started properly");
634 
635  if (_heap_profiling)
636  {
637  HeapProfilerStart(heap_profile_file.c_str());
638  if (!IsHeapProfilerRunning())
639  mooseError("Heap profiler is not started properly");
640  }
641  }
642 #else
643  if (std::getenv("MOOSE_PROFILE_BASE") || std::getenv("MOOSE_HEAP_BASE"))
644  mooseError("gperftool is not available for CPU or heap profiling");
645 #endif
646 
647  // If this will be a language server then turn off output until that starts
648  if (isParamValid("language_server") && getParam<bool>("language_server"))
649  _output_buffer_cache = Moose::out.rdbuf(nullptr);
650 
651  Registry::addKnownLabel(_type);
652  Moose::registerAll(_factory, _action_factory, _syntax);
653 
654  _the_warehouse = std::make_unique<TheWarehouse>();
655  _the_warehouse->registerAttribute<AttribMatrixTags>("matrix_tags", 0);
656  _the_warehouse->registerAttribute<AttribVectorTags>("vector_tags", 0);
657  _the_warehouse->registerAttribute<AttribExecOns>("exec_ons", 0);
658  _the_warehouse->registerAttribute<AttribSubdomains>("subdomains", 0);
659  _the_warehouse->registerAttribute<AttribBoundaries>("boundaries", 0);
660  _the_warehouse->registerAttribute<AttribThread>("thread", 0);
661  _the_warehouse->registerAttribute<AttribExecutionOrderGroup>("execution_order_group", 0);
662  _the_warehouse->registerAttribute<AttribPreIC>("pre_ic", 0);
663  _the_warehouse->registerAttribute<AttribPreAux>("pre_aux");
664  _the_warehouse->registerAttribute<AttribPostAux>("post_aux");
665  _the_warehouse->registerAttribute<AttribName>("name", "dummy");
666  _the_warehouse->registerAttribute<AttribSystem>("system", "dummy");
667  _the_warehouse->registerAttribute<AttribVar>("variable", -1);
668  _the_warehouse->registerAttribute<AttribInterfaces>("interfaces", 0);
669  _the_warehouse->registerAttribute<AttribSysNum>("sys_num", libMesh::invalid_uint);
670  _the_warehouse->registerAttribute<AttribResidualObject>("residual_object");
671  _the_warehouse->registerAttribute<AttribSorted>("sorted");
672  _the_warehouse->registerAttribute<AttribDisplaced>("displaced", -1);
673 
674  _perf_graph.enableLivePrint();
675 
676  if (_check_input && isParamSetByUser("recover"))
677  mooseError("Cannot run --check-input with --recover. Recover files might not exist");
678 
679  if (isParamSetByUser("start_in_debugger") && isUltimateMaster())
680  {
681  auto command = getParam<std::string>("start_in_debugger");
682 
683  Moose::out << "Starting in debugger using: " << command << std::endl;
684 
685  auto hostname = MooseUtils::hostname();
686 
687  std::stringstream command_stream;
688 
689  // This will start XTerm and print out some info first... then run the debugger
690  command_stream << "xterm -e \"echo 'Rank: " << processor_id() << " Hostname: " << hostname
691  << " PID: " << getpid() << "'; echo ''; ";
692 
693  // Figure out how to run the debugger
694  if (command.find("lldb") != std::string::npos || command.find("gdb") != std::string::npos)
695  command_stream << command << " -p " << getpid();
696  else
697  mooseError("Unknown debugger: ",
698  command,
699  "\nIf this is truly what you meant then contact moose-users to have a discussion "
700  "about adding your debugger.");
701 
702  // Finish up the command
703  command_stream << "\"" << " & ";
704  std::string command_string = command_stream.str();
705  Moose::out << "Running: " << command_string << std::endl;
706 
707  int ret = std::system(command_string.c_str());
708  libmesh_ignore(ret);
709 
710  // Sleep to allow time for the debugger to attach
711  std::this_thread::sleep_for(std::chrono::seconds(10));
712  }
713 
714  if (isParamSetByUser("stop_for_debugger") && isUltimateMaster())
715  {
716  Moose::out << "\nStopping for " << getParam<unsigned int>("stop_for_debugger")
717  << " seconds to allow attachment from a debugger.\n";
718 
719  Moose::out << "\nAll of the processes you can connect to:\n";
720  Moose::out << "rank - hostname - pid\n";
721 
722  auto hostname = MooseUtils::hostname();
723 
724  {
725  // The 'false' turns off the serialization warning
726  SerializerGuard sg(_communicator, false); // Guarantees that the processors print in order
727  Moose::err << processor_id() << " - " << hostname << " - " << getpid() << "\n";
728  }
729 
730  Moose::out << "\nWaiting...\n" << std::endl;
731 
732  // Sleep to allow time for the debugger to attach
733  std::this_thread::sleep_for(std::chrono::seconds(getParam<unsigned int>("stop_for_debugger")));
734  }
735 
736  if (_master_mesh && isUltimateMaster())
737  mooseError("Mesh can be passed in only for sub-apps");
738 
739  if (_master_displaced_mesh && !_master_mesh)
740  mooseError("_master_mesh should have been set when _master_displaced_mesh is set");
741 
742 #ifdef MOOSE_MFEM_ENABLED
743  if (_mfem_device)
744  {
745  mooseAssert(!isUltimateMaster(),
746  "The MFEM device should only be auto-set for sub-applications");
747  mooseAssert(!_mfem_devices.empty(),
748  "If we are a sub-application and we have an MFEM device object, then we must know "
749  "its configuration string");
750  }
751 #endif
752 
753  // Data specifically associated with the mesh (meta-data) that will read from the restart
754  // file early during the simulation setup so that they are available to Actions and other objects
755  // that need them during the setup process. Most of the restartable data isn't made available
756  // until all objects have been created and all Actions have been executed (i.e. initialSetup).
757  registerRestartableDataMapName(MooseApp::MESH_META_DATA, MooseApp::MESH_META_DATA_SUFFIX);
758 
759  if (_pars.have_parameter<bool>("use_legacy_dirichlet_bc"))
760  mooseDeprecated("The parameter 'use_legacy_dirichlet_bc' is no longer valid.\n\n",
761  "All Dirichlet boundary conditions are preset by default.\n\n",
762  "Remove said parameter in ",
763  name(),
764  " to remove this deprecation warning.");
765 
766  if (_test_restep && _test_checkpoint_half_transient)
767  mooseError("Cannot use --test-restep and --test-checkpoint-half-transient together");
768 
769  registerCapabilities();
770 
771  Moose::out << std::flush;
772 
773 #ifdef MOOSE_KOKKOS_ENABLED
774 #ifdef MOOSE_ENABLE_KOKKOS_GPU
775  queryKokkosGPUs();
776 #endif
777 #endif
778 }
779 
780 std::optional<MooseEnum>
781 MooseApp::getComputeDevice() const
782 {
783  if (isParamSetByUser("compute_device"))
784  return getParam<MooseEnum>("compute_device");
785  return {};
786 }
787 
788 void
789 MooseApp::registerCapabilities()
790 {
791  // helper lambdas
792  auto haveCapability = [](const std::string & capability, const std::string & doc)
793  { addCapability(capability, true, doc + " is available."); };
794 
795  auto missingCapability =
796  [](const std::string & capability, const std::string & doc, const std::string & help = "")
797  { addCapability(capability, false, doc + " is not available. " + help); };
798 
799  auto haveCapabilityVersion =
800  [](const std::string & capability, const std::string & doc, const std::string & version)
801  { addCapability(capability, version, doc + " version " + version + " is available."); };
802 
803  auto petscMissingCapability = [](const std::string & capability, const std::string & doc)
804  {
805  addCapability(
806  capability, false, doc + " is not available. Check your PETSc configure options.");
807  };
808 
809  auto libmeshMissingCapability =
810  [](const std::string & capability, const std::string & doc, const std::string & config_option)
811  {
812  addCapability(capability,
813  false,
814  doc + " is not available. It is controlled by the `" + config_option +
815  "` libMesh configure option.");
816  };
817 
818  // register capabilities
819  if (_trap_fpe)
820  addCapability("trap_fpe",
821  true,
822  "Trapping floating point exceptions is enabled (in debug mode this "
823  "can be disabled using the --no-trap-fpe option).");
824  else
825  addCapability("trap_fpe",
826  false,
827  "Trapping floating point exceptions is not enabled (enable them using "
828  "the --trap-fpe option or by running a debug mode executable).");
829 
830  {
831  const auto doc = "LibTorch machine learning and parallel tensor algebra library";
832 #ifdef MOOSE_LIBTORCH_ENABLED
833  addCapability("libtorch", TORCH_VERSION, doc);
834 #else
835  missingCapability("libtorch",
836  doc,
837  "Check "
838  "https://mooseframework.inl.gov/moose/getting_started/installation/"
839  "install_libtorch.html for "
840  "instructions on how to configure and build moose with libTorch.");
841 #endif
842  }
843 
844  {
845  const auto doc = "MFEM finite element library";
846 #ifdef MOOSE_MFEM_ENABLED
847  haveCapability("mfem", doc);
848 #else
849  missingCapability("mfem",
850  doc,
851  "Install mfem using the scripts/update_and_rebuild_mfem.sh script after "
852  "first running scripts/update_and_rebuild_conduit.sh. Finally, configure "
853  "moose with ./configure --with-mfem");
854 #endif
855  }
856 
857  {
858  const auto doc = "New Engineering Material model Library, version 2";
859 #ifdef NEML2_ENABLED
860  haveCapability("neml2", doc);
861 #else
862  missingCapability("neml2",
863  doc,
864  "Install neml2 using the scripts/update_and_rebuild_neml2.sh script, then "
865  "configure moose with ./configure --with-neml2 --with-libtorch");
866 #endif
867  }
868 
869  {
870  const auto doc = "gperftools code performance analysis and profiling library";
871 #ifdef HAVE_GPERFTOOLS
872  haveCapability("gperftools", doc);
873 #else
874  missingCapability("gperftools",
875  doc,
876  "Check https://mooseframework.inl.gov/application_development/profiling.html "
877  "for instructions on profiling MOOSE based applications.");
878 #endif
879  }
880 
881  {
882  const auto doc = "libPNG portable network graphics format library";
883 #ifdef MOOSE_HAVE_LIBPNG
884  haveCapability("libpng", doc);
885 #else
886  missingCapability("libpng",
887  doc,
888  "Install libpng through conda or your distribution and check that it gets "
889  "detected through pkg-config, then reconfigure and rebuild MOOSE.");
890 #endif
891  }
892 
893  {
894  const auto doc = "NVIDIA GPU parallel computing platform";
895 #ifdef PETSC_HAVE_CUDA
896  haveCapability("cuda", doc);
897 #else
898  missingCapability("cuda", doc, "Add the CUDA bin directory to your path and rebuild PETSc.");
899 #endif
900  }
901 
902  {
903  const auto doc = "Kokkos performance portability programming ecosystem";
904 #ifdef MOOSE_KOKKOS_ENABLED
905  haveCapability("kokkos", doc);
906 #else
907  missingCapability("kokkos",
908  doc,
909  "Rebuild PETSc with Kokkos support and libMesh. Then, reconfigure MOOSE with "
910  "--with-kokkos.");
911 #endif
912  }
913 
914  {
915  const auto doc = "Kokkos support for PETSc";
916 #ifdef PETSC_HAVE_KOKKOS
917  haveCapability("petsc_kokkos", doc);
918 #else
919  missingCapability(
920  "kokkos", doc, "Rebuild PETSc with Kokkos support, then rebuild libMesh and MOOSE.");
921 #endif
922  }
923 
924  addCapability(
925  "ad_size",
926  MOOSE_AD_MAX_DOFS_PER_ELEM,
927  "MOOSE was configured and built with a dual number backing store size of " +
928  Moose::stringify(MOOSE_AD_MAX_DOFS_PER_ELEM) +
929  ". Complex simulations with many variables or contact problems may require larger "
930  "values. Reconfigure MOOSE with the --with-derivative-size=<n> option in the root of the "
931  "repository.");
932  {
933  const std::string method = QUOTE(METHOD);
934  addCapability("method", method, "The executable was built with METHOD=\"" + method + "\"");
935  }
936 
937  {
938  const std::string version = QUOTE(LIBMESH_DETECTED_PETSC_VERSION_MAJOR) "." QUOTE(
939  LIBMESH_DETECTED_PETSC_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_PETSC_VERSION_SUBMINOR);
940  addCapability("petsc", version, "Using PETSc version " + version + ".");
941  }
942 
943 #ifdef LIBMESH_PETSC_USE_DEBUG
944  addCapability("petsc_debug", true, "PETSc was built with debugging options.");
945 #else
946  addCapability("petsc_debug", false, "PETSc was built without debugging options.");
947 #endif
948 
949  {
950  const auto doc = "SuperLU direct solver";
951 #ifdef LIBMESH_PETSC_HAVE_SUPERLU_DIST
952  haveCapability("superlu", doc);
953 #else
954  petscMissingCapability("superlu", doc);
955 #endif
956  }
957 
958  {
959  const auto doc = "MUltifrontal Massively Parallel sparse direct Solver (MUMPS)";
960 #ifdef LIBMESH_PETSC_HAVE_MUMPS
961  haveCapability("mumps", doc);
962 #else
963  petscMissingCapability("mumps", doc);
964 #endif
965  }
966 
967  {
968  const auto doc = "STRUMPACK - STRUctured Matrix PACKage solver library";
969 #ifdef LIBMESH_PETSC_HAVE_STRUMPACK
970  haveCapability("strumpack", doc);
971 #else
972  petscMissingCapability("strumpack", doc);
973 #endif
974  }
975 
976  {
977  const auto doc = "Parmetis partitioning library";
978 #if defined(LIBMESH_PETSC_HAVE_PARMETIS) || defined(LIBMESH_HAVE_PARMETIS)
979  haveCapability("parmetis", doc);
980 #else
981  petscMissingCapability("parmetis", doc);
982 #endif
983  }
984 
985  {
986  const auto doc = "Chaco graph partitioning library";
987 #ifdef LIBMESH_PETSC_HAVE_CHACO
988  haveCapability("chaco", doc);
989 #else
990  petscMissingCapability("chaco", doc);
991 #endif
992  }
993 
994  {
995  const auto doc = "Party matrix or graph partitioning library";
996 #ifdef LIBMESH_PETSC_HAVE_PARTY
997  haveCapability("party", doc);
998 #else
999  petscMissingCapability("party", doc);
1000 #endif
1001  }
1002 
1003  {
1004  const auto doc = "PT-Scotch graph partitioning library";
1005 #ifdef LIBMESH_PETSC_HAVE_PTSCOTCH
1006  haveCapability("ptscotch", doc);
1007 #else
1008  petscMissingCapability("ptscotch", doc);
1009 #endif
1010  }
1011 
1012  {
1013  const auto doc = "Scalable Library for Eigenvalue Problem Computations (SLEPc)";
1014 #ifdef LIBMESH_HAVE_SLEPC
1015  const auto version = QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_MAJOR) "." QUOTE(
1016  LIBMESH_DETECTED_SLEPC_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_SUBMINOR);
1017  haveCapabilityVersion("slepc", doc, version);
1018 #else
1019  petscMissingCapability("slepc", doc);
1020 #endif
1021  }
1022 
1023  {
1024  const auto doc = "Exodus mesh file format library";
1025 #ifdef LIBMESH_HAVE_EXODUS_API
1026  const std::string version = QUOTE(LIBMESH_DETECTED_EXODUS_VERSION_MAJOR) "." QUOTE(
1027  LIBMESH_DETECTED_EXODUS_VERSION_MINOR);
1028  haveCapabilityVersion("exodus", doc, version);
1029 #else
1030  libmeshMissingCapability("exodus", doc, "--enable-exodus");
1031 #endif
1032  }
1033 
1034  {
1035  const auto doc = "Netgen meshing library";
1036 #ifdef LIBMESH_HAVE_NETGEN
1037  haveCapability("netgen", doc);
1038 #else
1039  libmeshMissingCapability("netgen", doc, "--enable-netgen");
1040 #endif
1041  }
1042 
1043  {
1044  const auto doc = "Visualization Toolkit (VTK)";
1045 #ifdef LIBMESH_HAVE_VTK
1046  const std::string version = QUOTE(LIBMESH_DETECTED_VTK_VERSION_MAJOR) "." QUOTE(
1047  LIBMESH_DETECTED_VTK_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_VTK_VERSION_SUBMINOR);
1048  haveCapabilityVersion("vtk", doc, version);
1049 #else
1050  libmeshMissingCapability("vtk", doc, "--disable-vtk and --enable-vtk-required");
1051 #endif
1052  }
1053 
1054  {
1055  const auto doc = "libcurl - the multiprotocol file transfer library";
1056 #ifdef LIBMESH_HAVE_CURL
1057  haveCapability("curl", doc);
1058 #else
1059  libmeshMissingCapability("curl", doc, "--enable-curl");
1060 #endif
1061  }
1062 
1063  {
1064  const auto doc = "Tecplot post-processing tools API";
1065 #ifdef LIBMESH_HAVE_TECPLOT_API
1066  haveCapability("tecplot", doc);
1067 #else
1068  libmeshMissingCapability("tecplot", doc, "--enable-tecplot");
1069 #endif
1070  }
1071 
1072  {
1073  const auto doc = "Boost C++ library";
1074 #ifdef LIBMESH_HAVE_EXTERNAL_BOOST
1075  haveCapability("boost", doc);
1076 #else
1077  libmeshMissingCapability("boost", doc, "--with-boost");
1078 #endif
1079  }
1080 
1081  // libmesh stuff
1082  {
1083  const auto doc = "Adaptive mesh refinement";
1084 #ifdef LIBMESH_ENABLE_AMR
1085  haveCapability("amr", doc);
1086 #else
1087  libmeshMissingCapability("amr", doc, "--disable-amr");
1088 #endif
1089  }
1090 
1091  {
1092  const auto doc = "nanoflann library for Nearest Neighbor (NN) search with KD-trees";
1093 #ifdef LIBMESH_HAVE_NANOFLANN
1094  haveCapability("nanoflann", doc);
1095 #else
1096  libmeshMissingCapability("nanoflann", doc, "--disable-nanoflann");
1097 #endif
1098  }
1099 
1100  {
1101  const auto doc = "sfcurves library for space filling curves (required by geometric "
1102  "partitioners such as SFCurves, Hilbert and Morton - not LGPL compatible)";
1103 #ifdef LIBMESH_HAVE_SFCURVES
1104  haveCapability("sfcurves", doc);
1105 #else
1106  libmeshMissingCapability("sfcurves", doc, "--disable-sfc");
1107 #endif
1108  }
1109 
1110 #ifdef LIBMESH_HAVE_FPARSER
1111 #ifdef LIBMESH_HAVE_FPARSER_JIT
1112  addCapability("fparser", "jit", "FParser enabled with just in time compilation support.");
1113 #else
1114  addCapability("fparser", "byte_code", "FParser enabled.");
1115 #endif
1116 #else
1117  addCapability("fparser",
1118  false,
1119  "FParser is disabled, libMesh was likely configured with --disable-fparser.");
1120 #endif
1121 
1122 #ifdef LIBMESH_HAVE_DLOPEN
1123  addCapability(
1124  "dlopen", true, "The dlopen() system call is available to dynamically load libraries.");
1125 #else
1126  addCapability("dlopen",
1127  false,
1128  "The dlopen() system call is not available. Dynamic library loading is "
1129  "not supported on this system.");
1130 #endif
1131 
1132  {
1133  const auto doc = "LibMesh support for threaded execution";
1134 #ifdef LIBMESH_USING_THREADS
1135  haveCapability("threads", doc);
1136 #else
1137  libmeshMissingCapability("threads", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
1138 #endif
1139  }
1140 
1141  {
1142  const auto doc = "OpenMP multi-platform shared-memory parallel programming API";
1143 #ifdef LIBMESH_HAVE_OPENMP
1144  haveCapability("openmp", doc);
1145 #else
1146  libmeshMissingCapability("openmp", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
1147 #endif
1148  }
1149  {
1150  const auto doc = "oneAPI Threading Building Blocks (TBB) API";
1151 #ifdef LIBMESH_HAVE_TBB_API
1152  haveCapability("tbb", doc);
1153 #else
1154  libmeshMissingCapability("tbb", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
1155 #endif
1156  }
1157 
1158  {
1159  const auto doc = "libMesh unique ID support";
1160 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1161  haveCapability("unique_id", doc);
1162 #else
1163  libmeshMissingCapability("unique_id", doc, "--enable-unique-id");
1164 #endif
1165  }
1166 
1167  {
1168  const auto doc = "libMesh default mesh mode";
1169 #ifdef LIBMESH_ENABLE_PARMESH
1170  addCapability("mesh_mode", "distributed", doc);
1171 #else
1172  addCapability("mesh_mode", "replicated", doc);
1173 #endif
1174  }
1175 
1176  addCapability("dof_id_bytes",
1177  static_cast<int>(sizeof(dof_id_type)),
1178  "Degree of freedom (DOF) identifiers use " + Moose::stringify(sizeof(dof_id_type)) +
1179  " bytes for storage. This is controlled by the "
1180  "--with-dof-id-bytes=<1|2|4|8> libMesh configure option.");
1181 
1182  // compiler
1183  {
1184  const auto doc = "Compiler used to build the MOOSE framework.";
1185 #if defined(__INTEL_LLVM_COMPILER)
1186  addCapability("compiler", "intel", doc);
1187 #elif defined(__clang__)
1188  addCapability("compiler", "clang", doc);
1189 #elif defined(__GNUC__) || defined(__GNUG__)
1190  addCapability("compiler", "gcc", doc);
1191 #elif defined(_MSC_VER)
1192  addCapability("compiler", "msvc", doc);
1193 #else
1194  addCapability("compiler", false, "Unknown compiler");
1195 #endif
1196  }
1197 
1198  // OS related
1199  {
1200  const auto doc = "Operating system this executable is running on.";
1201 #ifdef __APPLE__
1202  addCapability("platform", "darwin", doc);
1203 #elif __WIN32__
1204  addCapability("platform", "win32", doc);
1205 #elif __linux__
1206  addCapability("platform", "linux", doc);
1207 #elif __unix__ // all unices not caught above
1208  addCapability("platform", "unix", doc);
1209 #endif
1210  }
1211 }
MooseUtils::makedirs
void makedirs(const std::string &dir_name, bool throw_on_failure)
Definition: MooseUtils.C:449
libMesh::ParallelObject::ParallelObject
ParallelObject(const Parallel::Communicator &comm_in)
MooseApp::_use_eigen_value
bool _use_eigen_value
Boolean to indicate whether to use an eigenvalue executioner.
Definition: MooseApp.h:1288
MooseApp::_multiapp_level
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
Definition: MooseApp.h:1555
MooseApp::_perf_graph
PerfGraph & _perf_graph
The PerfGraph object for this application (recoverable)
Definition: MooseApp.h:1251
Moose::show_trace
bool show_trace
Set to true (the default) to print the stack trace with error and warning messages - false to omit it...
Definition: Moose.C:800
MooseApp::_type
const std::string _type
The string representation of the type of this object as registered (see registerApp(AppName)) ...
Definition: MooseApp.h:1187
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
MooseApp::_initial_from_file
bool _initial_from_file
This variable indicates when a request has been made to restart from an Exodus file.
Definition: MooseApp.h:1309
libMesh::n_threads
unsigned int n_threads()
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseApp::createRecoverablePerfGraph
PerfGraph & createRecoverablePerfGraph()
Creates a recoverable PerfGraph.
Definition: MooseApp.C:3579
libMesh::invalid_uint
const unsigned int invalid_uint
MooseApp::registerCapabilities
void registerCapabilities()
Register all base MooseApp capabilities to the Moose::Capabilities registry.
MooseApp::_parser
const std::shared_ptr< Parser > _parser
Parser for parsing the input file (owns the root hit node)
Definition: MooseApp.h:1230
MooseBase::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:388
MooseApp::_global_time_offset
Real _global_time_offset
Offset of the local App time to the "global" problem time.
Definition: MooseApp.h:1211
MooseApp::determineLibtorchDeviceType
torch::DeviceType determineLibtorchDeviceType(const MooseEnum &device) const
Function to determine the device which should be used by libtorch on this application.
Definition: MooseApp.C:3618
MooseApp::_file_base_set_by_user
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
Definition: MooseApp.h:1196
MooseApp::_output_position_set
bool _output_position_set
Whether or not an output position has been set for this app.
Definition: MooseApp.h:1199
MooseApp::_the_warehouse
std::unique_ptr< TheWarehouse > _the_warehouse
The combined warehouse for storing any MooseObject based object.
Definition: MooseApp.h:1552
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2270
MooseUtils::tokenizeAndConvert
bool tokenizeAndConvert(const std::string &str, std::vector< T > &tokenized_vector, const std::string &delimiter=" \\\)
tokenizeAndConvert splits a string using delimiter and then converts to type T.
Definition: MooseStringUtils.h:162
MooseApp::_use_nonlinear
bool _use_nonlinear
Boolean to indicate whether to use a Nonlinear or EigenSystem (inspected by actions) ...
Definition: MooseApp.h:1285
MooseApp::MESH_META_DATA
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:130
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
MooseApp::_use_master_mesh
const bool _use_master_mesh
Whether to use the parent app mesh for this app.
Definition: MooseApp.h:1561
MooseApp::_start_time
Real _start_time
The time at which to start the simulation.
Definition: MooseApp.h:1208
AttribSorted
This attribute describes sorting state.
Definition: TheWarehouse.h:112
MooseApp::forceRestart
bool forceRestart() const
Whether or not we are forcefully restarting (allowing the load of potentially incompatibie checkpoint...
Definition: MooseApp.h:1068
MooseApp::_use_split
const bool _use_split
Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)
Definition: MooseApp.h:1327
MooseApp::_check_input
bool _check_input
true if we want to just check the input file
Definition: MooseApp.h:1347
AttribPreAux
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
Definition: Attributes.h:313
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
MooseApp::_mfem_devices
std::set< std::string > _mfem_devices
MFEM supported devices based on user-provided config.
Definition: MooseApp.h:1623
MooseApp::_syntax
Syntax _syntax
Syntax of the input file.
Definition: MooseApp.h:1214
MooseApp::_test_restep
const bool _test_restep
Whether or not this simulation should fail its middle timestep and repeat (for testing) ...
Definition: MooseApp.h:1341
MooseApp::_trap_fpe
bool _trap_fpe
Whether or not FPE trapping should be turned on.
Definition: MooseApp.h:1333
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
MooseApp::processor_id
processor_id_type processor_id() const
Returns the MPI processor ID of the current processor.
Definition: MooseApp.h:411
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
MooseApp::_rd_reader
RestartableDataReader _rd_reader
Definition: MooseApp.h:1575
moose::internal::ExecFlagRegistry::getExecFlagRegistry
static ExecFlagRegistry & getExecFlagRegistry()
Return Singleton instance.
Definition: ExecFlagRegistry.C:19
MooseApp::_solution_invalidity
SolutionInvalidity & _solution_invalidity
The SolutionInvalidity object for this application.
Definition: MooseApp.h:1254
MooseUtils::hostname
std::string hostname()
Definition: MooseUtils.C:624
MooseApp::getComputeDevice
std::optional< MooseEnum > getComputeDevice() const
Get the device accelerated computations are supposed to be running on.
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242
MooseApp::_rank_map
const RankMap _rank_map
The RankMap is a useful object for determining how the processes are laid out on the physical hardwar...
Definition: MooseApp.h:1257
MooseApp::_test_checkpoint_half_transient
const bool _test_checkpoint_half_transient
Whether or not this simulation should only run half its transient (useful for testing recovery) ...
Definition: MooseApp.h:1339
MooseApp::_exit_code
int _exit_code
The exit code.
Definition: MooseApp.h:1306
MooseBase::getCheckedPointerParam
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...
Definition: MooseBase.h:432
AttribPreIC
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
Definition: Attributes.h:294
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
MooseApp::_start_time_set
bool _start_time_set
Whether or not an start time has been set.
Definition: MooseApp.h:1205
libmesh_ignore
void libmesh_ignore(const Args &...)
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::_null_executor
std::shared_ptr< NullExecutor > _null_executor
Used to return an executor that does nothing.
Definition: MooseApp.h:1282
AttribSysNum
Tracks the libmesh system number that a MooseObject is associated with.
Definition: Attributes.h:275
MooseApp::_restart
bool _restart
Whether or not this is a restart run.
Definition: MooseApp.h:1321
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
MooseApp::queryKokkosGPUs
void queryKokkosGPUs()
Query the Kokkos GPUs in the system and check whether every process has an associated GPU...
AttribBoundaries
AttribBoundaries tracks all boundary IDs associated with an object.
Definition: Attributes.h:188
MooseApp::_action_factory
ActionFactory _action_factory
The Factory responsible for building Actions.
Definition: MooseApp.h:1221
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check
MooseApp::_recover
bool _recover
Whether or not this is a recovery run.
Definition: MooseApp.h:1318
MooseApp::_command_line
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1233
MooseApp::_error_overridden
bool _error_overridden
Indicates whether warnings or errors are displayed when overridden parameters are detected...
Definition: MooseApp.h:1301
MooseApp::createRecoverableSolutionInvalidity
SolutionInvalidity & createRecoverableSolutionInvalidity()
Creates a recoverable SolutionInvalidity.
Definition: MooseApp.C:3597
MooseApp::_heap_profiling
bool _heap_profiling
Memory profiling.
Definition: MooseApp.h:1596
MooseApp::_master_displaced_mesh
const MooseMesh *const _master_displaced_mesh
The displaced mesh from master app.
Definition: MooseApp.h:1567
AttribPostAux
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
Definition: Attributes.h:344
Moose::stringify
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
MooseApp::_force_restart
const bool _force_restart
Whether or not we are forcefully attempting to load checkpoints (–force-restart) ...
Definition: MooseApp.h:1330
AppFactory::instance
static AppFactory & instance()
Get the instance of the AppFactory.
Definition: AppFactory.C:18
AttribResidualObject
Residual objects have this attribute.
Definition: Attributes.h:411
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition: InputParameters.h:2329
MooseApp::_execute_flags
const ExecFlagEnum _execute_flags
Execution flags for this App.
Definition: MooseApp.h:1584
help
std::string help
Definition: PetscDMMoose.C:1711
MooseApp::registerRestartableDataMapName
void registerRestartableDataMapName(const RestartableDataMapName &name, std::string suffix="")
Reserve a location for storing custom RestartableDataMap objects.
Definition: MooseApp.C:3560
MooseApp::_chain_control_system
ChainControlDataSystem _chain_control_system
The system that manages the ChainControls.
Definition: MooseApp.h:1573
MooseApp::_distributed_mesh_on_command_line
bool _distributed_mesh_on_command_line
This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh...
Definition: MooseApp.h:1315
MooseApp::_builder
Moose::Builder _builder
Builder for building app related parser tree.
Definition: MooseApp.h:1239
MooseApp::_libtorch_device
const torch::DeviceType _libtorch_device
The libtorch device this app is using (converted from compute_device)
Definition: MooseApp.h:1615
MooseApp::_output_warehouse
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:1227
MooseApp::_output_buffer_cache
std::streambuf * _output_buffer_cache
Cache output buffer so the language server can turn it off then back on.
Definition: MooseApp.h:1587
MooseApp::_cpu_profiling
bool _cpu_profiling
CPU profiling.
Definition: MooseApp.h:1593
Moose::registerAll
void registerAll(Factory &f, ActionFactory &af, Syntax &s)
Register objects that are in MOOSE.
Definition: Moose.C:67
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::MESH_META_DATA_SUFFIX
static const std::string MESH_META_DATA_SUFFIX
Definition: MooseApp.h:131
MooseApp::_automatic_automatic_scaling
const bool _automatic_automatic_scaling
Whether to turn on automatic scaling by default.
Definition: MooseApp.h:1590
MooseApp::_factory
Factory _factory
Definition: MooseApp.h:1298
MooseApp::_input_parameter_warehouse
std::unique_ptr< InputParameterWarehouse > _input_parameter_warehouse
Input parameter storage structure; unique_ptr so we can control its destruction order.
Definition: MooseApp.h:1218
AttribDisplaced
Tracks whether the object is on the displaced mesh.
Definition: Attributes.h:481
MooseApp::addCapability
static void addCapability(const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
register a new capability
Definition: MooseApp.C:3678
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199
PerfGraphInterface::PerfGraphInterface
PerfGraphInterface(const MooseObject *moose_object)
For objects that are MooseObjects with a default prefix of type()
Definition: PerfGraphInterface.C:22
MooseApp::_multiapp_number
unsigned int _multiapp_number
Numbering in all the sub-apps on the same level.
Definition: MooseApp.h:1558
MooseApp::_comm
const std::shared_ptr< libMesh::Parallel::Communicator > _comm
The MPI communicator this App is going to use.
Definition: MooseApp.h:1190
MooseApp::_mfem_device
std::shared_ptr< mfem::Device > _mfem_device
The MFEM Device object.
Definition: MooseApp.h:1620
MooseApp::_ready_to_exit
bool _ready_to_exit
Definition: MooseApp.h:1304
MooseApp::_master_mesh
const MooseMesh *const _master_mesh
The mesh from master app.
Definition: MooseApp.h:1564
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205
SerializerGuard
A scope guard that guarantees that whatever happens between when it gets created and when it is destr...
Definition: SerializerGuard.h:24
MooseApp::_split_mesh
bool _split_mesh
Whether or not we are performing a split mesh operation (–split-mesh)
Definition: MooseApp.h:1324
MooseApp::_use_executor
const bool _use_executor
Indicates whether we are operating in the new/experimental executor mode instead of using the legacy ...
Definition: MooseApp.h:1279
PerfGraph::enableLivePrint
void enableLivePrint()
Enables Live Print.
Definition: PerfGraph.C:57
Registry::addKnownLabel
static char addKnownLabel(const std::string &label)
addKnownLabel whitelists a label as valid for purposes of the checkLabels function.
Definition: Registry.C:84
MooseBase::MooseBase
MooseBase(const InputParameters &params)
Primary constructor for general objects.
Definition: MooseBase.C:51
dof_id_type
uint8_t dof_id_type
MooseApp::_early_exit_param
std::string _early_exit_param
Indicates if simulation is ready to exit, and keeps track of which param caused it to exit...
Definition: MooseApp.h:1303
MooseApp::_initial_backup
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 ...
Definition: MooseApp.h:1611

Member Function Documentation

◆ actionWarehouse() [1/2]

ActionWarehouse& MooseApp::actionWarehouse ( )
inline

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

Definition at line 211 of file MooseApp.h.

Referenced by ElementIDOutputAction::act(), MeshOnlyAction::act(), SplitMeshAction::act(), MaterialOutputAction::act(), MeshGeneratorSystem::appendingMeshGenerators(), 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().

211 { return _action_warehouse; }
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224

◆ actionWarehouse() [2/2]

const ActionWarehouse& MooseApp::actionWarehouse ( ) const
inline

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

Definition at line 215 of file MooseApp.h.

215 { return _action_warehouse; }
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224

◆ addAppParam()

void MooseApp::addAppParam ( InputParameters &  params)
static

Definition at line 94 of file MooseApp.C.

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

95 {
96  params.addCommandLineParam<std::string>(
97  "app_to_run", "--app <type>", "Specify the application type to run (case-sensitive)");
98 }
InputParameters::addCommandLineParam
void addCommandLineParam(const std::string &name, const std::string &syntax, const std::string &doc_string)
Definition: InputParameters.h:1987

◆ addCapability() [1/2]

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

register a new capability

Definition at line 3678 of file MooseApp.C.

3681 {
3682  checkReservedCapability(capability);
3683  Moose::Capabilities::getCapabilityRegistry().add(capability, value, doc);
3684 }
Moose::Capabilities::getCapabilityRegistry
static Capabilities & getCapabilityRegistry()
Definition: Capabilities.C:22
MooseApp::checkReservedCapability
static void checkReservedCapability(const std::string &capability)
Helper that reports an error if the given capability is reserved and should not be added via addCapab...
Definition: MooseApp.C:2449
Moose::Capabilities::add
void add(const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
register a new capability
Definition: Capabilities.C:33

◆ addCapability() [2/2]

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

Definition at line 3687 of file MooseApp.C.

3688 {
3689  checkReservedCapability(capability);
3690  Moose::Capabilities::getCapabilityRegistry().add(capability, std::string(value), doc);
3691 }
Moose::Capabilities::getCapabilityRegistry
static Capabilities & getCapabilityRegistry()
Definition: Capabilities.C:22
MooseApp::checkReservedCapability
static void checkReservedCapability(const std::string &capability)
Helper that reports an error if the given capability is reserved and should not be added via addCapab...
Definition: MooseApp.C:2449
Moose::Capabilities::add
void add(const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
register a new capability
Definition: Capabilities.C:33

◆ addExecutor()

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

Definition at line 2050 of file MooseApp.C.

Referenced by recursivelyCreateExecutors().

2053 {
2054  std::shared_ptr<Executor> executor = _factory.create<Executor>(type, name, params);
2055 
2056  if (_executors.count(executor->name()) > 0)
2057  mooseError("an executor with name '", executor->name(), "' already exists");
2058  _executors[executor->name()] = executor;
2059 }
MooseApp::_executors
std::map< std::string, std::shared_ptr< Executor > > _executors
Pointers to all of the Executors for this run.
Definition: MooseApp.h:1266
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
libMesh::Factory::create
virtual std::unique_ptr< Base > create()=0
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::_factory
Factory _factory
Definition: MooseApp.h:1298
Executor
The Executor class directs the execution flow of simulations.
Definition: Executor.h:26

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

Referenced by ReadExecutorParamsAction::act().

2065 {
2066  _executor_params[name] = std::make_pair(type, std::make_unique<InputParameters>(params));
2067 }
MooseApp::_executor_params
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> ...
Definition: MooseApp.h:1271
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ addInputParam()

void MooseApp::addInputParam ( InputParameters &  params)
static

Definition at line 101 of file MooseApp.C.

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

102 {
103  params.addCommandLineParam<std::vector<std::string>>(
104  "input_file", "-i <input file(s)>", "Specify input file(s); multiple files are merged");
105 }
InputParameters::addCommandLineParam
void addCommandLineParam(const std::string &name, const std::string &syntax, const std::string &doc_string)
Definition: InputParameters.h:1987

◆ 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
typeThe type of MeshGenerator
nameThe name of the MeshGenerator
paramsThe params used to construct the MeshGenerator

See MeshGeneratorSystem::addMeshGenerator()

Definition at line 856 of file MooseApp.h.

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

859  {
860  _mesh_generator_system.addMeshGenerator(type, name, params);
861  }
MeshGeneratorSystem::addMeshGenerator
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.
Definition: MeshGeneratorSystem.C:35
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

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

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

3108 {
3109  // We prefer to always add geometric RMs. There is no hurt to add RMs for replicated mesh
3110  // since MeshBase::delete_remote_elements{} is a no-op (empty) for replicated mesh.
3111  // The motivation here is that MooseMesh::_use_distributed_mesh may not be properly set
3112  // at the time we are adding geometric relationship managers. We deleted the following
3113  // old logic to add all geometric RMs regardless of there is a distributed mesh or not.
3114  // Otherwise, all geometric RMs will be improperly ignored for a distributed mesh generator.
3115 
3116  // if (!_action_warehouse.mesh()->isDistributedMesh() && !_split_mesh &&
3117  // (relationship_manager->isType(Moose::RelationshipManagerType::GEOMETRIC) &&
3118  // !(relationship_manager->isType(Moose::RelationshipManagerType::ALGEBRAIC) ||
3119  // relationship_manager->isType(Moose::RelationshipManagerType::COUPLING))))
3120  // return false;
3121 
3122  bool add = true;
3123 
3124  std::set<std::shared_ptr<RelationshipManager>> rms_to_erase;
3125 
3126  for (const auto & existing_rm : _relationship_managers)
3127  {
3128  if (*existing_rm >= *new_rm)
3129  {
3130  add = false;
3131  donateForWhom(*new_rm, *existing_rm);
3132  break;
3133  }
3134  // The new rm did not provide less or the same amount/type of ghosting as the existing rm, but
3135  // what about the other way around?
3136  else if (*new_rm >= *existing_rm)
3137  rms_to_erase.emplace(existing_rm);
3138  }
3139 
3140  if (add)
3141  {
3142  _relationship_managers.emplace(new_rm);
3143  for (const auto & rm_to_erase : rms_to_erase)
3144  {
3145  donateForWhom(*rm_to_erase, *new_rm);
3146  removeRelationshipManager(rm_to_erase);
3147  }
3148  }
3149 
3150  // Inform the caller whether the object was added or not
3151  return add;
3152 }
MooseApp::removeRelationshipManager
void removeRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Purge this relationship manager from meshes and DofMaps and finally from us.
Definition: MooseApp.C:3209
MooseApp::_relationship_managers
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1350

◆ allocateKokkosMemoryPool()

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

Allocate Kokkos memory pool.

Parameters
sizeThe memory pool size in the number of bytes
waysThe number of parallel ways

◆ appBinaryName()

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

Definition at line 144 of file MooseApp.h.

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

145  {
146  auto name = Moose::getExecutableName();
147  name = name.substr(0, name.find_last_of("-"));
148  if (name.find_first_of("/") != std::string::npos)
149  name = name.substr(name.find_first_of("/") + 1, std::string::npos);
150  return name;
151  }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
Moose::getExecutableName
std::string getExecutableName()
Gets the name of the running executable on Mac OS X and linux.
Definition: ExecutablePath.C:60

◆ 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
typeThe type of MeshGenerator
nameThe name of the MeshGenerator
paramsThe params used to construct the MeshGenerator

See MeshGeneratorSystem::appendMeshGenerator()

Definition at line 907 of file MooseApp.h.

908  {
909  return _mesh_generator_system.appendMeshGenerator(type, name, params);
910  }
MeshGeneratorSystem::appendMeshGenerator
const MeshGenerator & appendMeshGenerator(const std::string &type, const std::string &name, InputParameters params)
Append a mesh generator that will act on the current final mesh generator in the system.
Definition: MeshGeneratorSystem.C:53
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

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

Referenced by dynamicAllRegistration(), and dynamicAppRegistration().

2538 {
2539  std::string library_name(app_name);
2540 
2541  // Strip off the App part (should always be the last 3 letters of the name)
2542  size_t pos = library_name.find("App");
2543  if (pos != library_name.length() - 3)
2544  mooseError("Invalid application name: ", library_name);
2545  library_name.erase(pos);
2546 
2547  // Now get rid of the camel case, prepend lib, and append the method and suffix
2548  return std::string("lib") + MooseUtils::camelCaseToUnderscore(library_name) + '-' +
2549  QUOTE(METHOD) + ".la";
2550 }
MooseUtils::camelCaseToUnderscore
std::string camelCaseToUnderscore(const std::string &camel_case_name)
Definition: MooseUtils.C:568
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ attachRelationshipManagers() [1/2]

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

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

Definition at line 3320 of file MooseApp.C.

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

3322 {
3323  for (auto & rm : _relationship_managers)
3324  {
3325  if (!rm->isType(rm_type))
3326  continue;
3327 
3328  // RM is already attached (this also handles the geometric early case)
3329  if (_attached_relationship_managers[rm_type].count(rm.get()))
3330  continue;
3331 
3332  if (rm_type == Moose::RelationshipManagerType::GEOMETRIC)
3333  {
3334  // The problem is not built yet - so the ActionWarehouse currently owns the mesh
3335  MooseMesh * const mesh = _action_warehouse.mesh().get();
3336 
3337  // "attach_geometric_rm_final = true" inidicate that it is the last chance to attach
3338  // geometric RMs. Therefore, we need to attach them.
3339  if (!rm->attachGeometricEarly() && !attach_geometric_rm_final)
3340  // Will attach them later (during algebraic). But also, we need to tell the mesh that we
3341  // shouldn't be deleting remote elements yet
3342  mesh->allowRemoteElementRemoval(false);
3343  else
3344  {
3345  MeshBase & undisp_mesh_base = mesh->getMesh();
3346  const DofMap * const undisp_sys_dof_map =
3347  _executioner ? &feProblem().getSolverSystem(0).dofMap() : nullptr;
3348  undisp_mesh_base.add_ghosting_functor(
3349  createRMFromTemplateAndInit(*rm, *mesh, undisp_mesh_base, undisp_sys_dof_map));
3350 
3351  // In the final stage, if there is a displaced mesh, we need to
3352  // clone ghosting functors for displacedMesh
3353  if (auto & disp_moose_mesh = _action_warehouse.displacedMesh();
3354  attach_geometric_rm_final && disp_moose_mesh)
3355  {
3356  MeshBase & disp_mesh_base = _action_warehouse.displacedMesh()->getMesh();
3357  const DofMap * disp_sys_dof_map = nullptr;
3358  if (_executioner && feProblem().getDisplacedProblem())
3359  disp_sys_dof_map = &feProblem().getDisplacedProblem()->solverSys(0).dofMap();
3360  disp_mesh_base.add_ghosting_functor(
3361  createRMFromTemplateAndInit(*rm, *disp_moose_mesh, disp_mesh_base, disp_sys_dof_map));
3362  }
3363  else if (_action_warehouse.displacedMesh())
3364  mooseError("The displaced mesh should not yet exist at the time that we are attaching "
3365  "early geometric relationship managers.");
3366 
3367  // Mark this RM as attached
3368  mooseAssert(!_attached_relationship_managers[rm_type].count(rm.get()), "Already attached");
3369  _attached_relationship_managers[rm_type].insert(rm.get());
3370  }
3371  }
3372  else // rm_type is algebraic or coupling
3373  {
3374  if (!_executioner && !_executor)
3375  mooseError("We must have an executioner by now or else we do not have to data to add "
3376  "algebraic or coupling functors to in MooseApp::attachRelationshipManagers");
3377 
3378  // Now we've built the problem, so we can use it
3379  auto & problem = feProblem();
3380  auto & undisp_moose_mesh = problem.mesh();
3381  auto & undisp_sys = feProblem().getSolverSystem(0);
3382  auto & undisp_sys_dof_map = undisp_sys.dofMap();
3383  auto & undisp_mesh = undisp_moose_mesh.getMesh();
3384 
3385  if (rm->useDisplacedMesh() && problem.getDisplacedProblem())
3386  {
3387  if (rm_type == Moose::RelationshipManagerType::COUPLING)
3388  // We actually need to add this to the FEProblemBase NonlinearSystemBase's DofMap
3389  // because the DisplacedProblem "nonlinear" DisplacedSystem doesn't have any matrices
3390  // for which to do coupling. It's actually horrifying to me that we are adding a
3391  // coupling functor, that is going to determine its couplings based on a displaced
3392  // MeshBase object, to a System associated with the undisplaced MeshBase object (there
3393  // is only ever one EquationSystems object per MeshBase object and visa versa). So here
3394  // I'm left with the choice of whether to pass in a MeshBase object that is *not* the
3395  // MeshBase object that will actually determine the couplings or to pass in the MeshBase
3396  // object that is inconsistent with the System DofMap that we are adding the coupling
3397  // functor for! Let's err on the side of *libMesh* consistency and pass properly paired
3398  // MeshBase-DofMap
3399  problem.addCouplingGhostingFunctor(
3400  createRMFromTemplateAndInit(*rm, undisp_moose_mesh, undisp_mesh, &undisp_sys_dof_map),
3401  /*to_mesh = */ false);
3402 
3403  else if (rm_type == Moose::RelationshipManagerType::ALGEBRAIC)
3404  {
3405  auto & displaced_problem = *problem.getDisplacedProblem();
3406  auto & disp_moose_mesh = displaced_problem.mesh();
3407  auto & disp_mesh = disp_moose_mesh.getMesh();
3408  const DofMap * const disp_nl_dof_map = &displaced_problem.solverSys(0).dofMap();
3409  displaced_problem.addAlgebraicGhostingFunctor(
3410  createRMFromTemplateAndInit(*rm, disp_moose_mesh, disp_mesh, disp_nl_dof_map),
3411  /*to_mesh = */ false);
3412  }
3413  }
3414  else // undisplaced
3415  {
3416  if (rm_type == Moose::RelationshipManagerType::COUPLING)
3417  problem.addCouplingGhostingFunctor(
3418  createRMFromTemplateAndInit(*rm, undisp_moose_mesh, undisp_mesh, &undisp_sys_dof_map),
3419  /*to_mesh = */ false);
3420 
3421  else if (rm_type == Moose::RelationshipManagerType::ALGEBRAIC)
3422  problem.addAlgebraicGhostingFunctor(
3423  createRMFromTemplateAndInit(*rm, undisp_moose_mesh, undisp_mesh, &undisp_sys_dof_map),
3424  /*to_mesh = */ false);
3425  }
3426 
3427  // Mark this RM as attached
3428  mooseAssert(!_attached_relationship_managers[rm_type].count(rm.get()), "Already attached");
3429  _attached_relationship_managers[rm_type].insert(rm.get());
3430  }
3431  }
3432 }
MooseApp::_attached_relationship_managers
std::map< Moose::RelationshipManagerType, std::set< const RelationshipManager * > > _attached_relationship_managers
The relationship managers that have been attached (type -> RMs)
Definition: MooseApp.h:1354
displaced_problem
std::shared_ptr< DisplacedProblem > displaced_problem
Definition: PetscDMMoose.C:1800
ActionWarehouse::displacedMesh
std::shared_ptr< MooseMesh > & displacedMesh()
Definition: ActionWarehouse.h:273
mesh
MeshBase & mesh
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
MooseApp::feProblem
FEProblemBase & feProblem() const
Definition: MooseApp.C:2043
MooseApp::createRMFromTemplateAndInit
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 ...
Definition: MooseApp.C:3251
ActionWarehouse::mesh
std::shared_ptr< MooseMesh > & mesh()
Definition: ActionWarehouse.h:270
SystemBase::dofMap
virtual libMesh::DofMap & dofMap()
Gets writeable reference to the dof map.
Definition: SystemBase.C:1163
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:92
FEProblemBase::getDisplacedProblem
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
Definition: FEProblemBase.h:1824
MooseApp::_relationship_managers
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1350
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
FEProblemBase::getSolverSystem
SolverSystem & getSolverSystem(unsigned int sys_num)
Get non-constant reference to a solver system.
Definition: FEProblemBase.h:3489
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263
libMesh::MeshBase::add_ghosting_functor
void add_ghosting_functor(GhostingFunctor &ghosting_functor)

◆ attachRelationshipManagers() [2/2]

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

Attach geometric relationship managers to the given MeshBase object.

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

◆ backup() [1/2]

std::vector< std::filesystem::path > MooseApp::backup ( const std::filesystem::path &  folder_base)

Backs up the application to the folder folder_base.

Returns
The files that are written in the backup

Definition at line 1931 of file MooseApp.C.

Referenced by Checkpoint::output().

1932 {
1933  TIME_SECTION("backup", 2, "Backing Up Application to File");
1934 
1935  preBackup();
1936 
1937  RestartableDataWriter writer(*this, _restartable_data);
1938  return writer.write(folder_base);
1939 }
RestartableDataWriter
Writer for restartable data, to be read by the RestartableDataReader.
Definition: RestartableDataWriter.h:17
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242
MooseApp::preBackup
virtual void preBackup()
Insertion point for other apps that is called before backup()
Definition: MooseApp.h:739

◆ backup() [2/2]

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

Backs up the application memory in a Backup.

Returns
The backup

Definition at line 1942 of file MooseApp.C.

Referenced by finalizeRestore(), and restore().

1943 {
1944  TIME_SECTION("backup", 2, "Backing Up Application");
1945 
1946  RestartableDataWriter writer(*this, _restartable_data);
1947 
1948  preBackup();
1949 
1950  auto backup = std::make_unique<Backup>();
1951  writer.write(*backup->header, *backup->data);
1952 
1953  return backup;
1954 }
RestartableDataWriter
Writer for restartable data, to be read by the RestartableDataReader.
Definition: RestartableDataWriter.h:17
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242
MooseApp::preBackup
virtual void preBackup()
Insertion point for other apps that is called before backup()
Definition: MooseApp.h:739
MooseApp::backup
std::unique_ptr< Backup > backup()
Backs up the application memory in a Backup.
Definition: MooseApp.C:1942

◆ builder()

Moose::Builder& MooseApp::builder ( )
inline

Returns a writable reference to the builder.

Definition at line 220 of file MooseApp.h.

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

220 { return _builder; }
MooseApp::_builder
Moose::Builder _builder
Builder for building app related parser tree.
Definition: MooseApp.h:1239

◆ callMooseError() [1/2]

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

External method for calling moose error with added object context.

Parameters
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix

Definition at line 105 of file MooseBase.C.

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

108 {
109  callMooseError(&_app, _pars, msg, with_prefix, node);
110 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357

◆ callMooseError() [2/2]

void MooseBase::callMooseError ( MooseApp *const  app,
const InputParameters &  params,
std::string  msg,
const bool  with_prefix,
const hit::Node *  node 
)
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
appThe app pointer (if available); adds multiapp context and clears the console
paramsThe parameters, needed to obtain object information
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix

Definition at line 113 of file MooseBase.C.

118 {
119  if (!node)
120  node = MooseBase::getHitNode(params);
121 
122  std::string multiapp_prefix = "";
123  if (app)
124  {
125  if (!app->isUltimateMaster())
126  multiapp_prefix = app->name();
127  app->getOutputWarehouse().mooseConsole();
128  }
129 
130  if (with_prefix)
131  // False here because the hit context will get processed by the node
132  msg = messagePrefix(params, false) + msg;
133 
134  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node);
135 }
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
moose::internal::mooseErrorRaw
void mooseErrorRaw(std::string msg, const std::string &prefix="", const hit::Node *node=nullptr)
Main callback for emitting a moose error.
Definition: MooseError.C:53
OutputWarehouse::mooseConsole
void mooseConsole()
Send current output buffer to Console output objects.
Definition: OutputWarehouse.C:199
MooseBase::getHitNode
const hit::Node * getHitNode() const
Definition: MooseBase.h:136
MooseApp::getOutputWarehouse
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2525
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ checkInput()

bool MooseApp::checkInput ( ) const
inline

Returns whether the Application is running in check input mode.

Definition at line 930 of file MooseApp.h.

930 { return _check_input; }
MooseApp::_check_input
bool _check_input
true if we want to just check the input file
Definition: MooseApp.h:1347

◆ checkMetaDataIntegrity()

void MooseApp::checkMetaDataIntegrity ( ) const

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

Definition at line 3511 of file MooseApp.C.

Referenced by SetupRecoverFileBaseAction::act().

3512 {
3513  for (auto map_iter = _restartable_meta_data.begin(); map_iter != _restartable_meta_data.end();
3514  ++map_iter)
3515  {
3516  const RestartableDataMapName & name = map_iter->first;
3517  const RestartableDataMap & meta_data = map_iter->second.first;
3518 
3519  std::vector<std::string> not_declared;
3520 
3521  for (const auto & data : meta_data)
3522  if (!data.declared())
3523  not_declared.push_back(data.name());
3524 
3525  if (!not_declared.empty())
3526  {
3527  std::ostringstream oss;
3528  std::copy(
3529  not_declared.begin(), not_declared.end(), infix_ostream_iterator<std::string>(oss, ", "));
3530 
3531  mooseError("The following '",
3532  name,
3533  "' meta-data properties were retrieved but never declared: ",
3534  oss.str());
3535  }
3536  }
3537 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
RestartableDataMap
Storage for restartable data that is ordered based on insertion order.
Definition: RestartableDataMap.h:27
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
RestartableDataMapName
std::string RestartableDataMapName
Definition: MooseTypes.h:242
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ checkpointSuffix()

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

The file suffix for the checkpoint mesh.

Definition at line 3155 of file MooseApp.C.

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

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

◆ checkReservedCapability()

void MooseApp::checkReservedCapability ( const std::string &  capability)
staticprivate

Helper that reports an error if the given capability is reserved and should not be added via addCapability().

Definition at line 2449 of file MooseApp.C.

Referenced by addCapability().

2450 {
2451  // The list of these capabilities should match those within
2452  // Tester.checkRunnableBase() in the TestHarness
2453  static const std::set<std::string> reserved{
2454  "scale_refine", "valgrind", "recover", "heavy", "mpi_procs", "num_threads", "compute_device"};
2455  if (reserved.count(capability))
2456  ::mooseError("MooseApp::addCapability(): The capability \"",
2457  capability,
2458  "\" is reserved and may not be registered by an application.");
2459 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

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

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

418 { return _command_line; }
MooseApp::_command_line
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1233

◆ 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
parameterName of the controllable parameter of this action
object_typeType of the object added by this action.
object_nameName of the object added by this action.
object_parameterName of the parameter of the object.

Definition at line 77 of file MooseBase.C.

81 {
82  auto & factory = _app.getFactory();
83  auto & ip_warehouse = _app.getInputParameterWarehouse();
84 
85  MooseObjectParameterName primary_name(uniqueName(), parameter);
86  const auto base_type = factory.getValidParams(object_type).getBase();
87  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
88  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
89 
90  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
91  for (const auto & tag : tags)
92  {
93  if (!tag.empty())
94  {
95  // Only adds the parameter with the different control tags if the derived class
96  // properly registers the parameter to its own syntax
97  MooseObjectParameterName tagged_name(tag, name(), parameter);
98  ip_warehouse.addControllableParameterConnection(
99  tagged_name, secondary_name, /*error_on_empty=*/false);
100  }
101  }
102 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2270
MooseApp::getInputParameterWarehouse
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2983
MooseBase::uniqueName
MooseObjectName uniqueName() const
Definition: MooseBase.C:69
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:401
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
MooseObjectParameterName
A class for storing an input parameter name.
Definition: MooseObjectParameterName.h:26

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

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

3611 {
3612  return _action_warehouse.getCurrentTaskName() == "create_added_mesh_generators" ||
3613  _mesh_generator_system.appendingMeshGenerators();
3614 }
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
ActionWarehouse::getCurrentTaskName
const std::string & getCurrentTaskName() const
Definition: ActionWarehouse.h:280
MeshGeneratorSystem::appendingMeshGenerators
bool appendingMeshGenerators() const
Whether or not mesh generators are currently being appended (append_mesh_generator task) ...
Definition: MeshGeneratorSystem.C:664

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

Referenced by run().

2328 {
2329  if (isParamSetByUser("copy_inputs"))
2330  {
2331  if (comm().size() > 1)
2332  mooseError("The --copy-inputs option should not be ran in parallel");
2333 
2334  // Get command line argument following --copy-inputs on command line
2335  auto dir_to_copy = getParam<std::string>("copy_inputs");
2336 
2337  if (dir_to_copy.empty())
2338  mooseError("Error retrieving directory to copy");
2339  if (dir_to_copy.back() != '/')
2340  dir_to_copy += '/';
2341 
2342  // This binary name is the actual binary. That is, if we called a symlink it'll
2343  // be the name of what the symlink points to
2344  auto binname = appBinaryName();
2345  if (binname == "")
2346  mooseError("could not locate installed tests to run (unresolved binary/app name)");
2347 
2348  auto src_dir = MooseUtils::installedInputsDir(
2349  binname,
2350  dir_to_copy,
2351  "Rerun binary with " + _pars.getCommandLineMetadata("show_inputs").switches[0] +
2352  " to get a list of installable directories.");
2353 
2354  // Use the command line here because if we have a symlink to another binary,
2355  // we want to dump into a directory that is named after the symlink not the true binary
2356  auto dst_dir = _command_line->getExecutableNameBase() + "/" + dir_to_copy;
2357  auto cmdname = _command_line->getExecutableName();
2358  if (cmdname.find_first_of("/") != std::string::npos)
2359  cmdname = cmdname.substr(cmdname.find_first_of("/") + 1, std::string::npos);
2360 
2361  if (MooseUtils::pathExists(dst_dir))
2362  mooseError(
2363  "The directory \"./",
2364  dst_dir,
2365  "\" already exists.\nTo update/recopy the contents of this directory, rename (\"mv ",
2366  dst_dir,
2367  " new_dir_name\") or remove (\"rm -r ",
2368  dst_dir,
2369  "\") the existing directory.\nThen re-run \"",
2370  cmdname,
2371  " --copy-inputs ",
2372  dir_to_copy,
2373  "\".");
2374 
2375  std::string cmd = "mkdir -p " + dst_dir + "; rsync -av " + src_dir + " " + dst_dir;
2376 
2377  TIME_SECTION("copy_inputs", 2, "Copying Inputs");
2378 
2379  mooseAssert(comm().size() == 1, "Should be run in serial");
2380  const auto return_value = system(cmd.c_str());
2381  if (!WIFEXITED(return_value))
2382  mooseError("Process exited unexpectedly");
2383  setExitCode(WEXITSTATUS(return_value));
2384  if (exitCode() == 0)
2385  Moose::out << "Directory successfully copied into ./" << dst_dir << '\n';
2386  return true;
2387  }
2388  return false;
2389 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseApp::appBinaryName
virtual std::string appBinaryName() const
Definition: MooseApp.h:144
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
MooseApp::exitCode
int exitCode() const
Get the shell exit code for the application.
Definition: MooseApp.h:157
MooseUtils::installedInputsDir
std::string installedInputsDir(const std::string &app_name, const std::string &dir_name, const std::string &extra_error_msg)
Definition: MooseUtils.C:103
MooseApp::_command_line
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1233
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
InputParameters::getCommandLineMetadata
const InputParameters::CommandLineMetadata & getCommandLineMetadata(const std::string &name) const
Definition: InputParameters.C:1039
InputParameters::CommandLineMetadata::switches
std::vector< std::string > switches
The switches for the parameter (i.e., [-t, –timing])
Definition: InputParameters.h:91
MooseUtils::pathExists
bool pathExists(const std::string &path)
Definition: MooseUtils.C:247
MooseApp::setExitCode
void setExitCode(const int exit_code)
Sets the exit code that the application will exit with.
Definition: MooseApp.h:162
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205

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

Referenced by AddExecutorAction::act().

2136 {
2137  // Do we have any?
2138  if (_executor_params.empty())
2139  return;
2140 
2141  // Holds the names of Executors that may be the root executor
2142  std::list<std::string> possibly_root;
2143 
2144  // What is already built
2145  std::map<std::string, bool> already_built;
2146 
2147  // The Executors that are currently candidates for being roots
2148  std::list<std::string> possible_roots;
2149 
2150  // The current line of dependencies - used for finding cycles
2151  std::list<std::string> current_branch;
2152 
2153  // Build the NullExecutor
2154  {
2155  auto params = _factory.getValidParams("NullExecutor");
2156  _null_executor = _factory.create<NullExecutor>("NullExecutor", "_null_executor", params);
2157  }
2158 
2159  for (const auto & params_entry : _executor_params)
2160  {
2161  const auto & name = params_entry.first;
2162 
2163  // Did we already make this one?
2164  if (_executors.find(name) != _executors.end())
2165  continue;
2166 
2167  possible_roots.emplace_back(name);
2168 
2169  recursivelyCreateExecutors(name, possible_roots, current_branch);
2170  }
2171 
2172  // If there is more than one possible root - error
2173  if (possible_roots.size() > 1)
2174  {
2175  auto root_string_it = possible_roots.begin();
2176 
2177  std::stringstream roots_string;
2178 
2179  roots_string << *root_string_it++;
2180 
2181  for (; root_string_it != possible_roots.end(); ++root_string_it)
2182  roots_string << ", " << *root_string_it;
2183 
2184  mooseError("Multiple Executor roots found: ", roots_string.str());
2185  }
2186 
2187  // Set the root executor
2188  _executor = _executors[possible_roots.front()];
2189 }
MooseApp::_executor_params
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> ...
Definition: MooseApp.h:1271
MooseApp::recursivelyCreateExecutors
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.
Definition: MooseApp.C:2083
MooseApp::_executors
std::map< std::string, std::shared_ptr< Executor > > _executors
Pointers to all of the Executors for this run.
Definition: MooseApp.h:1266
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::_null_executor
std::shared_ptr< NullExecutor > _null_executor
Used to return an executor that does nothing.
Definition: MooseApp.h:1282
libMesh::Factory::create
virtual std::unique_ptr< Base > create()=0
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::_factory
Factory _factory
Definition: MooseApp.h:1298
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263

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

Referenced by setupOptions().

3008 {
3009  TIME_SECTION("createMinimalApp", 3, "Creating Minimal App");
3010 
3011  // SetupMeshAction
3012  {
3013  // Build the Action parameters
3014  InputParameters action_params = _action_factory.getValidParams("SetupMeshAction");
3015  action_params.set<std::string>("type") = "GeneratedMesh";
3016 
3017  // Create The Action
3018  std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
3019  _action_factory.create("SetupMeshAction", "Mesh", action_params));
3020 
3021  // Set the object parameters
3022  InputParameters & params = action->getObjectParams();
3023  params.set<MooseEnum>("dim") = "1";
3024  params.set<unsigned int>("nx") = 1;
3025 
3026  // Add Action to the warehouse
3027  _action_warehouse.addActionBlock(action);
3028  }
3029 
3030  // Executioner
3031  {
3032  // Build the Action parameters
3033  InputParameters action_params = _action_factory.getValidParams("CreateExecutionerAction");
3034  action_params.set<std::string>("type") = "Transient";
3035 
3036  // Create the action
3037  std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
3038  _action_factory.create("CreateExecutionerAction", "Executioner", action_params));
3039 
3040  // Set the object parameters
3041  InputParameters & params = action->getObjectParams();
3042  params.set<unsigned int>("num_steps") = 1;
3043  params.set<Real>("dt") = 1;
3044 
3045  // Add Action to the warehouse
3046  _action_warehouse.addActionBlock(action);
3047  }
3048 
3049  // Problem
3050  {
3051  // Build the Action parameters
3052  InputParameters action_params = _action_factory.getValidParams("CreateProblemDefaultAction");
3053  action_params.set<bool>("_solve") = false;
3054 
3055  // Create the action
3056  std::shared_ptr<Action> action = std::static_pointer_cast<Action>(
3057  _action_factory.create("CreateProblemDefaultAction", "Problem", action_params));
3058 
3059  // Add Action to the warehouse
3060  _action_warehouse.addActionBlock(action);
3061  }
3062 
3063  // Outputs
3064  {
3065  // Build the Action parameters
3066  InputParameters action_params = _action_factory.getValidParams("CommonOutputAction");
3067  action_params.set<bool>("console") = false;
3068 
3069  // Create action
3070  std::shared_ptr<Action> action =
3071  _action_factory.create("CommonOutputAction", "Outputs", action_params);
3072 
3073  // Add Action to the warehouse
3074  _action_warehouse.addActionBlock(action);
3075  }
3076 
3077  _action_warehouse.build();
3078 }
ActionFactory::getValidParams
InputParameters getValidParams(const std::string &name)
Definition: ActionFactory.C:94
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: InputParameters.h:1532
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:66
ActionWarehouse::addActionBlock
void addActionBlock(std::shared_ptr< Action > blk)
This method add an Action instance to the warehouse.
Definition: ActionWarehouse.C:79
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
Action
Base class for actions.
Definition: Action.h:34
ActionFactory::create
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters &parameters)
Definition: ActionFactory.C:40
MooseApp::_action_factory
ActionFactory _action_factory
The Factory responsible for building Actions.
Definition: MooseApp.h:1221
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
ActionWarehouse::build
void build()
Builds all auto-buildable tasks.
Definition: ActionWarehouse.C:53

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

3580 {
3581  registerRestartableNameWithFilter("perf_graph", Moose::RESTARTABLE_FILTER::RECOVERABLE);
3582 
3583  auto perf_graph =
3584  std::make_unique<RestartableData<PerfGraph>>("perf_graph",
3585  this,
3586  type() + " (" + name() + ')',
3587  *this,
3588  getParam<bool>("perf_graph_live_all"),
3589  !getParam<bool>("disable_perf_graph_live"));
3590 
3591  return dynamic_cast<RestartableData<PerfGraph> &>(
3592  registerRestartableData(std::move(perf_graph), 0, false))
3593  .set();
3594 }
MooseApp::registerRestartableNameWithFilter
void registerRestartableNameWithFilter(const std::string &name, Moose::RESTARTABLE_FILTER filter)
NOTE: This is an internal function meant for MOOSE use only!
Definition: MooseApp.C:1916
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::registerRestartableData
RestartableDataValue & registerRestartableData(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
Definition: MooseApp.C:2565
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215

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

3598 {
3599  registerRestartableNameWithFilter("solution_invalidity", Moose::RESTARTABLE_FILTER::RECOVERABLE);
3600 
3601  auto solution_invalidity =
3602  std::make_unique<RestartableData<SolutionInvalidity>>("solution_invalidity", nullptr, *this);
3603 
3604  return dynamic_cast<RestartableData<SolutionInvalidity> &>(
3605  registerRestartableData(std::move(solution_invalidity), 0, false))
3606  .set();
3607 }
MooseApp::registerRestartableNameWithFilter
void registerRestartableNameWithFilter(const std::string &name, Moose::RESTARTABLE_FILTER filter)
NOTE: This is an internal function meant for MOOSE use only!
Definition: MooseApp.C:1916
MooseApp::registerRestartableData
RestartableDataValue & registerRestartableData(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
Definition: MooseApp.C:2565
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215

◆ 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_rmThe relationship manager template from which we will clone
moose_meshThe moose mesh to use for initialization
meshThe mesh to use for initialization
dof_mapAn 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 3251 of file MooseApp.C.

Referenced by attachRelationshipManagers().

3255 {
3256  auto & mesh_to_clone = _template_to_clones[&template_rm];
3257  auto it = mesh_to_clone.find(&mesh);
3258  if (it != mesh_to_clone.end())
3259  {
3260  // We've already created a clone for this mesh
3261  auto & clone_rm = *it->second;
3262  if (!clone_rm.dofMap() && dof_map)
3263  // We didn't have a DofMap before, but now we do, so we should re-init
3264  clone_rm.init(moose_mesh, mesh, dof_map);
3265  else if (clone_rm.dofMap() && dof_map && (clone_rm.dofMap() != dof_map))
3266  mooseError("Attempting to create and initialize an existing clone with a different DofMap. "
3267  "This should not happen.");
3268 
3269  return clone_rm;
3270  }
3271 
3272  // It's possible that this method is going to get called for multiple different MeshBase
3273  // objects. If that happens, then we *cannot* risk having a MeshBase object with a ghosting
3274  // functor that is init'd with another MeshBase object. So the safe thing to do is to make a
3275  // different RM for every MeshBase object that gets called here. Then the
3276  // RelationshipManagers stored here in MooseApp are serving as a template only
3277  auto pr = mesh_to_clone.emplace(
3278  std::make_pair(&const_cast<const MeshBase &>(mesh),
3279  dynamic_pointer_cast<RelationshipManager>(template_rm.clone())));
3280  mooseAssert(pr.second, "An insertion should have happened");
3281  auto & clone_rm = *pr.first->second;
3282  clone_rm.init(moose_mesh, mesh, dof_map);
3283  return clone_rm;
3284 }
MooseApp::_template_to_clones
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...
Definition: MooseApp.h:1602
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
libMesh::GhostingFunctor::clone
virtual std::unique_ptr< GhostingFunctor > clone() const

◆ deallocateKokkosMemoryPool()

void MooseApp::deallocateKokkosMemoryPool ( )
private

Deallocate Kokkos memory pool.

Referenced by ~MooseApp().

◆ defaultAutomaticScaling()

bool MooseApp::defaultAutomaticScaling ( ) const
inline

Whether to enable automatic scaling by default.

Definition at line 1009 of file MooseApp.h.

1009 { return _automatic_automatic_scaling; }
MooseApp::_automatic_automatic_scaling
const bool _automatic_automatic_scaling
Whether to turn on automatic scaling by default.
Definition: MooseApp.h:1590

◆ 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
deviceEnum to describe if a cpu or a gpu should be used.

Definition at line 3618 of file MooseApp.C.

3619 {
3620  const auto pname = "--compute-device";
3621  if (device_enum == "cuda")
3622  {
3623 #ifdef __linux__
3624  if (!torch::cuda::is_available())
3625  mooseError(pname, "=cuda: CUDA support is not available in the linked libtorch library");
3626  return torch::kCUDA;
3627 #else
3628  mooseError(pname, "=cuda: CUDA is not supported on your platform");
3629 #endif
3630  }
3631  else if (device_enum == "mps")
3632  {
3633 #ifdef __APPLE__
3634  if (!torch::mps::is_available())
3635  mooseError(pname, "=mps: MPS support is not available in the linked libtorch library");
3636  return torch::kMPS;
3637 #else
3638  mooseError(pname, "=mps: MPS is not supported on your platform");
3639 #endif
3640  }
3641 
3642  else if (device_enum != "cpu")
3643  mooseError("The device '",
3644  device_enum,
3645  "' is not currently supported by the MOOSE libtorch integration.");
3646  return torch::kCPU;
3647 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ disableCheckUnusedFlag()

void MooseApp::disableCheckUnusedFlag ( )

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

Definition at line 2037 of file MooseApp.C.

2038 {
2039  _enable_unused_check = OFF;
2040 }
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check

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

Referenced by DynamicObjectRegistrationAction::DynamicObjectRegistrationAction().

2760 {
2761 #ifdef LIBMESH_HAVE_DLOPEN
2762  Parameters params;
2763  params.set<std::string>("app_name") = app_name;
2764  params.set<RegistrationType>("reg_type") = REGALL;
2765  params.set<std::string>("registration_method") = app_name + "__registerAll";
2766  params.set<std::string>("library_path") = library_path;
2767  params.set<std::string>("library_name") =
2768  library_name.empty() ? appNameToLibName(app_name) : library_name;
2769 
2770  params.set<Factory *>("factory") = factory;
2771  params.set<Syntax *>("syntax") = syntax;
2772  params.set<ActionFactory *>("action_factory") = action_factory;
2773  params.set<bool>("library_load_dependencies") = false;
2774 
2775  dynamicRegistration(params);
2776 #else
2777  libmesh_ignore(app_name, factory, action_factory, syntax, library_path, library_name);
2778  mooseError("Dynamic Loading is either not supported or was not detected by libMesh configure.");
2779 #endif
2780 }
MooseApp::dynamicRegistration
void dynamicRegistration(const libMesh::Parameters &params)
Helper method for dynamic loading of objects.
Definition: MooseApp.C:2783
MooseApp::syntax
Syntax & syntax()
Returns a writable reference to the syntax object.
Definition: MooseApp.h:225
libmesh_ignore
void libmesh_ignore(const Args &...)
ActionFactory
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:48
MooseApp::RegistrationType
RegistrationType
Enumeration for holding the valid types of dynamic registrations allowed.
Definition: MooseApp.h:1545
libMesh::Parameters::set
T & set(const std::string &)
Syntax
Holding syntax for parsing input files.
Definition: Syntax.h:21
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::appNameToLibName
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)
Definition: MooseApp.C:2537

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

Referenced by MultiApp::createApps().

2701 {
2702 #ifdef LIBMESH_HAVE_DLOPEN
2703  Parameters params;
2704  params.set<std::string>("app_name") = app_name;
2705  params.set<RegistrationType>("reg_type") = APPLICATION;
2706  params.set<std::string>("registration_method") = app_name + "__registerApps";
2707  params.set<std::string>("library_path") = library_path;
2708 
2709  const auto effective_library_name =
2710  library_name.empty() ? appNameToLibName(app_name) : library_name;
2711  params.set<std::string>("library_name") = effective_library_name;
2712  params.set<bool>("library_load_dependencies") = lib_load_deps;
2713 
2714  const auto paths = getLibrarySearchPaths(library_path);
2715  std::ostringstream oss;
2716 
2717  auto successfully_loaded = false;
2718  if (paths.empty())
2719  oss << '"' << app_name << "\" is not a registered application name.\n"
2720  << "No search paths were set. We made no attempts to locate the corresponding library "
2721  "file.\n";
2722  else
2723  {
2724  dynamicRegistration(params);
2725 
2726  // At this point the application should be registered so check it
2727  if (!AppFactory::instance().isRegistered(app_name))
2728  {
2729  oss << '"' << app_name << "\" is not a registered application name.\n"
2730  << "Unable to locate library archive for \"" << app_name
2731  << "\".\nWe attempted to locate the library archive \"" << effective_library_name
2732  << "\" in the following paths:\n\t";
2733  std::copy(paths.begin(), paths.end(), infix_ostream_iterator<std::string>(oss, "\n\t"));
2734  }
2735  else
2736  successfully_loaded = true;
2737  }
2738 
2739  if (!successfully_loaded)
2740  {
2741  oss << "\nMake sure you have compiled the library and either set the \"library_path\" "
2742  "variable in your input file or exported \"MOOSE_LIBRARY_PATH\".\n";
2743 
2744  mooseError(oss.str());
2745  }
2746 
2747 #else
2748  libmesh_ignore(app_name, library_path, library_name, lib_load_deps);
2749  mooseError("Dynamic Loading is either not supported or was not detected by libMesh configure.");
2750 #endif
2751 }
MooseApp::dynamicRegistration
void dynamicRegistration(const libMesh::Parameters &params)
Helper method for dynamic loading of objects.
Definition: MooseApp.C:2783
libmesh_ignore
void libmesh_ignore(const Args &...)
MooseApp::RegistrationType
RegistrationType
Enumeration for holding the valid types of dynamic registrations allowed.
Definition: MooseApp.h:1545
MooseApp::getLibrarySearchPaths
std::set< std::string > getLibrarySearchPaths(const std::string &library_path_from_param) const
Return the paths searched by MOOSE when loading libraries.
Definition: MooseApp.C:2957
AppFactory::instance
static AppFactory & instance()
Get the instance of the AppFactory.
Definition: AppFactory.C:18
libMesh::Parameters::set
T & set(const std::string &)
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::appNameToLibName
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)
Definition: MooseApp.C:2537

◆ dynamicRegistration()

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

Helper method for dynamic loading of objects.

Definition at line 2783 of file MooseApp.C.

Referenced by dynamicAllRegistration(), and dynamicAppRegistration().

2784 {
2785  const auto paths = getLibrarySearchPaths(params.get<std::string>("library_path"));
2786  const auto library_name = params.get<std::string>("library_name");
2787 
2788  // Attempt to dynamically load the library
2789  for (const auto & path : paths)
2790  if (MooseUtils::checkFileReadable(path + '/' + library_name, false, false))
2791  loadLibraryAndDependencies(
2792  path + '/' + library_name, params, params.get<bool>("library_load_dependencies"));
2793 }
libMesh::Parameters::get
const T & get(std::string_view) const
MooseApp::loadLibraryAndDependencies
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 applicatio...
Definition: MooseApp.C:2796
MooseApp::getLibrarySearchPaths
std::set< std::string > getLibrarySearchPaths(const std::string &library_path_from_param) const
Return the paths searched by MOOSE when loading libraries.
Definition: MooseApp.C:2957
MooseUtils::checkFileReadable
bool checkFileReadable(const std::string &filename, bool check_line_endings, bool throw_on_unreadable, bool check_for_git_lfs_pointer)
Definition: MooseUtils.C:254

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

Referenced by executeExecutioner(), and run().

1817 {
1818  bool warn = _enable_unused_check == WARN_UNUSED;
1819  bool err = _enable_unused_check == ERROR_UNUSED;
1820 
1821  _builder.errorCheck(*_comm, warn, err);
1822 
1823  // Return early for mesh only mode, since we want error checking to run even though
1824  // an executor is not created for this case
1825  if (isParamSetByUser("mesh_only"))
1826  return;
1827 
1828  if (!_executor.get() && !_executioner.get())
1829  {
1830  if (!_early_exit_param.empty())
1831  {
1832  mooseAssert(_check_input,
1833  "Something went wrong, we should only get here if _check_input is true.");
1834  mooseError(
1835  "Incompatible command line arguments provided. --check-input cannot be called with ",
1836  _early_exit_param,
1837  ".");
1838  }
1839  // We should never get here
1840  mooseError("The Executor is being called without being initialized. This is likely "
1841  "caused by "
1842  "incompatible command line arguments");
1843  }
1844 
1845  auto apps = feProblem().getMultiAppWarehouse().getObjects();
1846  for (auto app : apps)
1847  for (unsigned int i = 0; i < app->numLocalApps(); i++)
1848  app->localApp(i)->errorCheck();
1849 }
err
OStreamProxy err
MooseApp::_check_input
bool _check_input
true if we want to just check the input file
Definition: MooseApp.h:1347
FEProblemBase::getMultiAppWarehouse
ExecuteMooseObjectWarehouse< MultiApp > & getMultiAppWarehouse()
Definition: FEProblemBase.h:2333
MooseApp::feProblem
FEProblemBase & feProblem() const
Definition: MooseApp.C:2043
MooseObjectWarehouseBase::getObjects
const std::vector< std::shared_ptr< T > > & getObjects(THREAD_ID tid=0) const
Retrieve complete vector to the all/block/boundary restricted objects for a given thread...
Definition: MooseObjectWarehouseBase.h:371
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check
Moose::Builder::errorCheck
void errorCheck(const libMesh::Parallel::Communicator &comm, bool warn_unused, bool err_unused)
Definition: Builder.C:361
MooseApp::_builder
Moose::Builder _builder
Builder for building app related parser tree.
Definition: MooseApp.h:1239
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::_comm
const std::shared_ptr< libMesh::Parallel::Communicator > _comm
The MPI communicator this App is going to use.
Definition: MooseApp.h:1190
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263
MooseApp::_early_exit_param
std::string _early_exit_param
Indicates if simulation is ready to exit, and keeps track of which param caused it to exit...
Definition: MooseApp.h:1303

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

1043 { 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(); }
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ executeExecutioner()

void MooseApp::executeExecutioner ( )
virtual

Execute the Executioner that was built.

Definition at line 1852 of file MooseApp.C.

Referenced by run().

1853 {
1854  TIME_SECTION("executeExecutioner", 3);
1855 
1856  // If ready to exit has been set, then just return
1857  if (_ready_to_exit)
1858  return;
1859 
1860  // run the simulation
1861  if (_use_executor && _executor)
1862  {
1863  LibmeshPetscCall(Moose::PetscSupport::petscSetupOutput(_command_line.get()));
1864  _executor->init();
1865  errorCheck();
1866  auto result = _executor->exec();
1867  if (!result.convergedAll())
1868  mooseError(result.str());
1869  }
1870  else if (_executioner)
1871  {
1872  LibmeshPetscCall(Moose::PetscSupport::petscSetupOutput(_command_line.get()));
1873  _executioner->init();
1874  errorCheck();
1875  _executioner->execute();
1876  if (!_executioner->lastSolveConverged())
1877  setExitCode(1);
1878  }
1879  else
1880  mooseError("No executioner was specified (go fix your input file)");
1881 }
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseApp::_command_line
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1233
Moose::PetscSupport::petscSetupOutput
PetscErrorCode petscSetupOutput(CommandLine *cmd_line)
Definition: PetscSupport.C:251
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::setExitCode
void setExitCode(const int exit_code)
Sets the exit code that the application will exit with.
Definition: MooseApp.h:162
MooseApp::_ready_to_exit
bool _ready_to_exit
Definition: MooseApp.h:1304
MooseApp::_use_executor
const bool _use_executor
Indicates whether we are operating in the new/experimental executor mode instead of using the legacy ...
Definition: MooseApp.h:1279
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263
MooseApp::errorCheck
void errorCheck()
Runs post-initialization error checking that cannot be run correctly unless the simulation has been f...
Definition: MooseApp.C:1816

◆ exitCode()

int MooseApp::exitCode ( ) const
inline

Get the shell exit code for the application.

Returns
The shell exit code

Definition at line 157 of file MooseApp.h.

Referenced by copyInputs().

157 { return _exit_code; }
MooseApp::_exit_code
int _exit_code
The exit code.
Definition: MooseApp.h:1306

◆ feProblem()

FEProblemBase & MooseApp::feProblem ( ) const

Definition at line 2043 of file MooseApp.C.

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

2044 {
2045  mooseAssert(_executor.get() || _executioner.get(), "No executioner yet, calling too early!");
2046  return _executor.get() ? _executor->feProblem() : _executioner->feProblem();
2047 }
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263

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

Referenced by FEProblemBase::initialSetup().

2000 {
2001  if (!_rd_reader.isRestoring())
2002  mooseError("MooseApp::finalizeRestore(): Not currently restoring");
2003 
2004  // This gives us access to the underlying streams so that we can return it if needed
2005  auto input_streams = _rd_reader.clear();
2006 
2007  std::unique_ptr<Backup> backup;
2008 
2009  // Give them back a backup if this restore started from a Backup, in which case
2010  // the two streams in the Backup are formed into StringInputStreams
2011  if (auto header_string_input = dynamic_cast<StringInputStream *>(input_streams.header.get()))
2012  {
2013  auto data_string_input = dynamic_cast<StringInputStream *>(input_streams.data.get());
2014  mooseAssert(data_string_input, "Should also be a string input");
2015 
2016  auto header_sstream = header_string_input->release();
2017  mooseAssert(header_sstream, "Header not available");
2018 
2019  auto data_sstream = data_string_input->release();
2020  mooseAssert(data_sstream, "Data not available");
2021 
2022  backup = std::make_unique<Backup>();
2023  backup->header = std::move(header_sstream);
2024  backup->data = std::move(data_sstream);
2025  }
2026 
2027  return backup;
2028 }
MooseApp::_rd_reader
RestartableDataReader _rd_reader
Definition: MooseApp.h:1575
MooseApp::backup
std::unique_ptr< Backup > backup()
Backs up the application memory in a Backup.
Definition: MooseApp.C:1942
StringInputStream
Helper class that hands out input streams to a stringstream.
Definition: StringInputStream.h:19
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
RestartableDataReader::clear
InputStreams clear()
Clears the contents of the reader (header stream, data stream, header)
Definition: RestartableDataReader.C:65

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

Referenced by FixedPointSolve::FixedPointSolve().

386 { 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:1275

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

Referenced by possiblyLoadRestartableMetaData().

1068 { return _force_restart; }
MooseApp::_force_restart
const bool _force_restart
Whether or not we are forcefully attempting to load checkpoints (–force-restart) ...
Definition: MooseApp.h:1330

◆ getActionFactory()

ActionFactory& MooseApp::getActionFactory ( )
inline

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

Definition at line 406 of file MooseApp.h.

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

406 { return _action_factory; }
MooseApp::_action_factory
ActionFactory _action_factory
The Factory responsible for building Actions.
Definition: MooseApp.h:1221

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

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

147 { return _pars.getBase(); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::getBase
const std::string & getBase() const
Definition: InputParameters.C:497

◆ getChainControlDataSystem()

ChainControlDataSystem& MooseApp::getChainControlDataSystem ( )
inline

Gets the system that manages the ChainControls.

Definition at line 845 of file MooseApp.h.

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

845 { return _chain_control_system; }
MooseApp::_chain_control_system
ChainControlDataSystem _chain_control_system
The system that manages the ChainControls.
Definition: MooseApp.h:1573

◆ 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 432 of file MooseBase.h.

433 {
434  return _pars.getCheckedPointerParam<T>(name, error_string);
435 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::getCheckedPointerParam
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...
Definition: InputParameters.h:1726
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ getCheckpointDirectories()

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

Get all checkpoint directories.

Returns
A Set of checkpoint directories

Definition at line 2473 of file MooseApp.C.

Referenced by getCheckpointFiles().

2474 {
2475  // Storage for the directory names
2476  std::list<std::string> checkpoint_dirs;
2477 
2478  // Add the directories added with Outputs/checkpoint=true input syntax
2479  checkpoint_dirs.push_back(getOutputFileBase() + "_cp");
2480 
2481  // Add the directories from any existing checkpoint output objects
2482  const auto & actions = _action_warehouse.getActionListByName("add_output");
2483  for (const auto & action : actions)
2484  {
2485  // Get the parameters from the MooseObjectAction
2486  MooseObjectAction * moose_object_action = dynamic_cast<MooseObjectAction *>(action);
2487  if (!moose_object_action)
2488  continue;
2489 
2490  const InputParameters & params = moose_object_action->getObjectParams();
2491  if (moose_object_action->getParam<std::string>("type") == "Checkpoint")
2492  {
2493  // Unless file_base was explicitly set by user, we cannot rely on it, as it will be changed
2494  // later
2495  const std::string cp_dir =
2496  _file_base_set_by_user ? params.get<std::string>("file_base")
2497  : (getOutputFileBase(true) + "_" + moose_object_action->name());
2498  checkpoint_dirs.push_back(cp_dir + "_cp");
2499  }
2500  }
2501  return checkpoint_dirs;
2502 }
MooseBase::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:388
MooseApp::_file_base_set_by_user
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
Definition: MooseApp.h:1196
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2270
MooseApp::getOutputFileBase
std::string getOutputFileBase(bool for_non_moose_build_output=false) const
Get the output file base name.
Definition: MooseApp.C:1747
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:66
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
ActionWarehouse::getActionListByName
const std::list< Action * > & getActionListByName(const std::string &task) const
Retrieve a constant list of Action pointers associated with the passed in task.
Definition: ActionWarehouse.C:193
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseObjectAction::getObjectParams
InputParameters & getObjectParams()
Retrieve the parameters of the object to be created by this action.
Definition: MooseObjectAction.h:29

◆ getCheckpointFiles()

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

Extract all possible checkpoint file names.

Returns
A Set of checkpoint filenames

Definition at line 2505 of file MooseApp.C.

Referenced by setRestartRecoverFileBase().

2506 {
2507  auto checkpoint_dirs = getCheckpointDirectories();
2508  return MooseUtils::getFilesInDirs(checkpoint_dirs, false);
2509 }
MooseApp::getCheckpointDirectories
std::list< std::string > getCheckpointDirectories() const
Get all checkpoint directories.
Definition: MooseApp.C:2473
MooseUtils::getFilesInDirs
std::list< std::string > getFilesInDirs(const std::list< std::string > &directory_list, const bool files_only)
Definition: MooseUtils.C:808

◆ getCommunicator()

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

Definition at line 1012 of file MooseApp.h.

Referenced by MooseServer::parseDocumentForDiagnostics().

1012 { return _comm; }
MooseApp::_comm
const std::shared_ptr< libMesh::Parallel::Communicator > _comm
The MPI communicator this App is going to use.
Definition: MooseApp.h:1190

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

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

3179 {
3180  if (const auto action = _action_warehouse.getCurrentAction())
3181  return action->parameters().getHitNode();
3182  return nullptr;
3183 }
ActionWarehouse::getCurrentAction
const Action * getCurrentAction() const
Definition: ActionWarehouse.h:285
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224

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

Referenced by MooseMesh::determineUseDistributedMesh().

460 { return _distributed_mesh_on_command_line; }
MooseApp::_distributed_mesh_on_command_line
bool _distributed_mesh_on_command_line
This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh...
Definition: MooseApp.h:1315

◆ getExecuteOnEnum()

const ExecFlagEnum& MooseApp::getExecuteOnEnum ( ) const
inline

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

Definition at line 994 of file MooseApp.h.

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

994 { return _execute_flags; }
MooseApp::_execute_flags
const ExecFlagEnum _execute_flags
Execution flags for this App.
Definition: MooseApp.h:1584

◆ getExecutioner()

Executioner * MooseApp::getExecutioner ( ) const

Retrieve the Executioner for this App.

Definition at line 2206 of file MooseApp.C.

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

2207 {
2208  return _executioner.get() ? _executioner.get() : _executor.get();
2209 }
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263

◆ getExecutor() [1/2]

Executor* MooseApp::getExecutor ( ) const
inline

Definition at line 335 of file MooseApp.h.

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

335 { return _executor.get(); }
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263

◆ getExecutor() [2/2]

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

Get an Executor.

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

Definition at line 2192 of file MooseApp.C.

2193 {
2194  auto it = _executors.find(name);
2195 
2196  if (it != _executors.end())
2197  return *it->second;
2198 
2199  if (fail_if_not_found)
2200  mooseError("Executor not found: ", name);
2201 
2202  return *_null_executor;
2203 }
MooseApp::_executors
std::map< std::string, std::shared_ptr< Executor > > _executors
Pointers to all of the Executors for this run.
Definition: MooseApp.h:1266
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::_null_executor
std::shared_ptr< NullExecutor > _null_executor
Used to return an executor that does nothing.
Definition: MooseApp.h:1282
if
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

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

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

430 { return _initial_from_file; }
MooseApp::_initial_from_file
bool _initial_from_file
This variable indicates when a request has been made to restart from an Exodus file.
Definition: MooseApp.h:1309

◆ getExReaderForRestart()

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

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

Definition at line 443 of file MooseApp.h.

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

443 { 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:1312

◆ getFactory()

Factory& MooseApp::getFactory ( )
inline

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

Definition at line 401 of file MooseApp.h.

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

401 { return _factory; }
MooseApp::_factory
Factory _factory
Definition: MooseApp.h:1298

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

Referenced by ProgressOutput::output().

2520 {
2521  return _builder.getPrimaryFileName(stripLeadingPath);
2522 }
Moose::Builder::getPrimaryFileName
std::string getPrimaryFileName(bool stripLeadingPath=true) const
Return the primary (first) filename that was parsed.
Definition: Builder.C:179
MooseApp::_builder
Moose::Builder _builder
Builder for building app related parser tree.
Definition: MooseApp.h:1239

◆ getFPTrapFlag()

bool MooseApp::getFPTrapFlag ( ) const
inline

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

Definition at line 933 of file MooseApp.h.

933 { return _trap_fpe; }
MooseApp::_trap_fpe
bool _trap_fpe
Whether or not FPE trapping should be turned on.
Definition: MooseApp.h:1333

◆ getFrameworkVersion()

std::string MooseApp::getFrameworkVersion ( ) const

Returns the framework version.

Definition at line 1254 of file MooseApp.C.

1255 {
1256  return MOOSE_VERSION;
1257 }

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

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

312 { return _global_time_offset; }
MooseApp::_global_time_offset
Real _global_time_offset
Offset of the local App time to the "global" problem time.
Definition: MooseApp.h:1211

◆ getHitNode()

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.

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

136 { return getHitNode(_pars); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::getHitNode
const hit::Node * getHitNode() const
Definition: MooseBase.h:136

◆ getInputFileNames()

const std::vector< std::string > & MooseApp::getInputFileNames ( ) const
Returns
the input file names set in the Parser

Definition at line 1733 of file MooseApp.C.

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

1734 {
1735  mooseAssert(_parser, "Parser is not set");
1736  return _parser->getInputFileNames();
1737 }
MooseApp::_parser
const std::shared_ptr< Parser > _parser
Parser for parsing the input file (owns the root hit node)
Definition: MooseApp.h:1230

◆ getInputParameterWarehouse()

InputParameterWarehouse & MooseApp::getInputParameterWarehouse ( )

Get the InputParameterWarehouse for MooseObjects.

Definition at line 2983 of file MooseApp.C.

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

2984 {
2985  return *_input_parameter_warehouse;
2986 }
MooseApp::_input_parameter_warehouse
std::unique_ptr< InputParameterWarehouse > _input_parameter_warehouse
Input parameter storage structure; unique_ptr so we can control its destruction order.
Definition: MooseApp.h:1218

◆ getInstallableInputs()

std::string MooseApp::getInstallableInputs ( ) const
privatevirtual

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

Definition at line 2321 of file MooseApp.C.

Referenced by showInputs().

2322 {
2323  return "tests";
2324 }

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

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

1679 {
1680  static_assert(!std::is_base_of<MooseObject, T>::value, "T is not an interface");
1681 
1682  const auto it = _interface_registry.find(typeid(T));
1683  if (it != _interface_registry.end())
1684  return static_cast<InterfaceRegistryObjects<T> *>(it->second.get())->_objects;
1685  const static std::vector<T *> empty;
1686  return empty;
1687 }
MooseApp::_interface_registry
std::map< std::type_index, std::unique_ptr< InterfaceRegistryObjectsBase > > _interface_registry
Registration for interface objects.
Definition: MooseApp.h:1605

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

Referenced by setupOptions().

1741 {
1742  mooseAssert(_parser, "Parser is not set");
1743  return _parser->getLastInputFileName();
1744 }
MooseApp::_parser
const std::shared_ptr< Parser > _parser
Parser for parsing the input file (owns the root hit node)
Definition: MooseApp.h:1230

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

Referenced by dynamicAppRegistration(), and dynamicRegistration().

2958 {
2959  std::set<std::string> paths;
2960 
2961  if (!library_path.empty())
2962  {
2963  std::vector<std::string> tmp_paths;
2964  MooseUtils::tokenize(library_path, tmp_paths, 1, ":");
2965 
2966  paths.insert(tmp_paths.begin(), tmp_paths.end());
2967  }
2968 
2969  char * moose_lib_path_env = std::getenv("MOOSE_LIBRARY_PATH");
2970  if (moose_lib_path_env)
2971  {
2972  std::string moose_lib_path(moose_lib_path_env);
2973  std::vector<std::string> tmp_paths;
2974  MooseUtils::tokenize(moose_lib_path, tmp_paths, 1, ":");
2975 
2976  paths.insert(tmp_paths.begin(), tmp_paths.end());
2977  }
2978 
2979  return paths;
2980 }
MooseUtils::tokenize
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseStringUtils.h:55

◆ getLibtorchDevice()

torch::DeviceType MooseApp::getLibtorchDevice ( ) const
inline

Get the device torch is supposed to be running on.

Definition at line 111 of file MooseApp.h.

111 { return _libtorch_device; }
MooseApp::_libtorch_device
const torch::DeviceType _libtorch_device
The libtorch device this app is using (converted from compute_device)
Definition: MooseApp.h:1615

◆ getLoadedLibraryPaths()

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

Return the paths of loaded libraries.

Definition at line 2946 of file MooseApp.C.

Referenced by Factory::reportUnregisteredError().

2947 {
2948  // Return the paths but not the open file handles
2949  std::set<std::string> paths;
2950  for (const auto & it : _lib_handles)
2951  paths.insert(it.first);
2952 
2953  return paths;
2954 }
MooseApp::_lib_handles
std::unordered_map< std::string, DynamicLibraryInfo > _lib_handles
The library archive (name only), registration method and the handle to the method.
Definition: MooseApp.h:1371

◆ getMeshGenerator()

const MeshGenerator& MooseApp::getMeshGenerator ( const std::string &  name) const
inline
Returns
The MeshGenerator with the name name.

Definition at line 874 of file MooseApp.h.

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

875  {
876  return _mesh_generator_system.getMeshGenerator(name);
877  }
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGeneratorSystem::getMeshGenerator
const MeshGenerator & getMeshGenerator(const std::string &name) const
Definition: MeshGeneratorSystem.C:620

◆ getMeshGeneratorMesh()

std::unique_ptr<MeshBase> MooseApp::getMeshGeneratorMesh ( )
inline
Returns
The final mesh generated by the mesh generator system

Definition at line 882 of file MooseApp.h.

883  {
884  return _mesh_generator_system.getSavedMesh(_mesh_generator_system.mainMeshGeneratorName());
885  }
MeshGeneratorSystem::getSavedMesh
std::unique_ptr< libMesh::MeshBase > getSavedMesh(const std::string &name)
Get the saved mesh by name.
Definition: MeshGeneratorSystem.C:648
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
MeshGeneratorSystem::mainMeshGeneratorName
static std::string mainMeshGeneratorName()
The name reserved for the "main" mesh generator which is the one used for the numerical solver downst...
Definition: MeshGeneratorSystem.h:172

◆ getMeshGeneratorNames()

std::vector<std::string> MooseApp::getMeshGeneratorNames ( ) const
inline
Returns
The names of all mesh generators

See MeshGeneratorSystem::getMeshGeneratorNames()

Definition at line 892 of file MooseApp.h.

Referenced by SetupMeshAction::act().

893  {
894  return _mesh_generator_system.getMeshGeneratorNames();
895  }
MeshGeneratorSystem::getMeshGeneratorNames
std::vector< std::string > getMeshGeneratorNames() const
Get names of all mesh generators Note: This function should be called after all mesh generators are a...
Definition: MeshGeneratorSystem.C:630
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570

◆ getMeshGeneratorSystem()

MeshGeneratorSystem& MooseApp::getMeshGeneratorSystem ( )
inline

Gets the system that manages the MeshGenerators.

Definition at line 840 of file MooseApp.h.

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

840 { return _mesh_generator_system; }
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570

◆ getMFEMDevice()

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

Get the MFEM device object.

Definition at line 1086 of file MooseApp.h.

Referenced by MultiApp::createApp().

1086 { return _mfem_device; }
MooseApp::_mfem_device
std::shared_ptr< mfem::Device > _mfem_device
The MFEM Device object.
Definition: MooseApp.h:1620

◆ getMFEMDevices()

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

Get the configured MFEM devices.

Definition at line 1691 of file MooseApp.h.

Referenced by MultiApp::createApp().

1692 {
1693  return _mfem_devices;
1694 }
MooseApp::_mfem_devices
std::set< std::string > _mfem_devices
MFEM supported devices based on user-provided config.
Definition: MooseApp.h:1623

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const
inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

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

87 { return _app; }
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357

◆ getNullExecutor()

NullExecutor* MooseApp::getNullExecutor ( ) const
inline

Definition at line 336 of file MooseApp.h.

Referenced by ExecutorInterface::getExecutor().

336 { return _null_executor.get(); }
MooseApp::_null_executor
std::shared_ptr< NullExecutor > _null_executor
Used to return an executor that does nothing.
Definition: MooseApp.h:1282

◆ getOutputFileBase()

std::string MooseApp::getOutputFileBase ( bool  for_non_moose_build_output = false) const

Get the output file base name.

Parameters
for_non_moose_build_outputTrue 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 1747 of file MooseApp.C.

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

1748 {
1749  if (_file_base_set_by_user || for_non_moose_build_output || _multiapp_level)
1750  return _output_file_base;
1751  else
1752  return _output_file_base + "_out";
1753 }
MooseApp::_multiapp_level
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
Definition: MooseApp.h:1555
MooseApp::_file_base_set_by_user
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
Definition: MooseApp.h:1196
MooseApp::_output_file_base
std::string _output_file_base
The output file basename.
Definition: MooseApp.h:1193

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

Referenced by TransientMultiApp::setupApp().

547  {
548  return _output_file_numbers;
549  }
MooseApp::_output_file_numbers
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 mu...
Definition: MooseApp.h:1344

◆ getOutputPosition()

Point MooseApp::getOutputPosition ( ) const
inline

Get the output position.

Returns
The position offset for the output.

Definition at line 282 of file MooseApp.h.

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

282 { return _output_position; }
MooseApp::_output_position
Point _output_position
The output position.
Definition: MooseApp.h:1202

◆ getOutputWarehouse() [1/2]

OutputWarehouse & MooseApp::getOutputWarehouse ( )

Get the OutputWarehouse objects.

Definition at line 2525 of file MooseApp.C.

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

2526 {
2527  return _output_warehouse;
2528 }
MooseApp::_output_warehouse
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:1227

◆ getOutputWarehouse() [2/2]

const OutputWarehouse & MooseApp::getOutputWarehouse ( ) const

Definition at line 2531 of file MooseApp.C.

2532 {
2533  return _output_warehouse;
2534 }
MooseApp::_output_warehouse
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:1227

◆ getParam() [1/2]

template<typename T >
const T & MooseBase::getParam ( const std::string &  name) const
inherited

Retrieve a parameter for the object.

Parameters
nameThe name of the parameter
Returns
The value of the parameter

Definition at line 388 of file MooseBase.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FEProblemBase::addOutput(), DiffusionPhysicsBase::addPostprocessors(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), ComponentPhysicsInterface::ComponentPhysicsInterface(), FunctorAux::computeValue(), Console::Console(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), Output::setWallTimeIntervalFromCommandLineParam(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

389 {
390  return InputParameters::getParamHelper<T>(name, _pars);
391 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ 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
param1The name of first parameter
param2The name of second parameter
Returns
Vector of pairs of first and second parameters

Definition at line 425 of file MooseBase.h.

426 {
427  return _pars.get<T1, T2>(param1, param2);
428 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2270

◆ getPrintableName()

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

Get printable name of the application.

Definition at line 142 of file MooseApp.h.

Referenced by getPrintableVersion().

142 { return "Application"; }

◆ getPrintableVersion()

std::string MooseApp::getPrintableVersion ( ) const

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

Definition at line 1266 of file MooseApp.C.

Referenced by setupOptions().

1267 {
1268  return getPrintableName() + " Version: " + getVersion();
1269 }
MooseApp::getPrintableName
virtual std::string getPrintableName() const
Get printable name of the application.
Definition: MooseApp.h:142
MooseApp::getVersion
virtual std::string getVersion() const
Returns the current version of the framework or application (default: framework version).
Definition: MooseApp.C:1260

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

Referenced by restore().

721 { 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:1248

◆ getRecoverFileBase()

std::string MooseApp::getRecoverFileBase ( ) const
inline

Definition at line 495 of file MooseApp.h.

496  {
497  mooseDeprecated("MooseApp::getRecoverFileBase is deprecated, use "
498  "MooseApp::getRestartRecoverFileBase() instead.");
499  return _restart_recover_base;
500  }
MooseApp::_restart_recover_base
std::string _restart_recover_base
The base name to restart/recover from. If blank then we will find the newest checkpoint file...
Definition: MooseApp.h:1336
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314

◆ getRelationshipManagerInfo()

std::vector< std::pair< std::string, std::string > > MooseApp::getRelationshipManagerInfo ( ) const

Returns the Relationship managers info suitable for printing.

Definition at line 3435 of file MooseApp.C.

Referenced by ConsoleUtils::outputRelationshipManagerInformation().

3436 {
3437  std::vector<std::pair<std::string, std::string>> info_strings;
3438  info_strings.reserve(_relationship_managers.size());
3439 
3440  for (const auto & rm : _relationship_managers)
3441  {
3442  std::stringstream oss;
3443  oss << rm->getInfo();
3444 
3445  auto & for_whom = rm->forWhom();
3446 
3447  if (!for_whom.empty())
3448  {
3449  oss << " for ";
3450 
3451  std::copy(for_whom.begin(), for_whom.end(), infix_ostream_iterator<std::string>(oss, ", "));
3452  }
3453 
3454  info_strings.emplace_back(std::make_pair(Moose::stringify(rm->getType()), oss.str()));
3455  }
3456 
3457  // List the libMesh GhostingFunctors - Not that in libMesh all of the algebraic and coupling
3458  // Ghosting Functors are also attached to the mesh. This should catch them all.
3459  const auto & mesh = _action_warehouse.getMesh();
3460  if (mesh)
3461  {
3462  // Let us use an ordered map to avoid stochastic console behaviors.
3463  // I believe we won't have many RMs, and there is no performance issue.
3464  // Deterministic behaviors are good for setting up regression tests
3465  std::map<std::string, unsigned int> counts;
3466 
3467  for (auto & gf : as_range(mesh->getMesh().ghosting_functors_begin(),
3468  mesh->getMesh().ghosting_functors_end()))
3469  {
3470  const auto * gf_ptr = dynamic_cast<const RelationshipManager *>(gf);
3471  if (!gf_ptr)
3472  // Count how many occurences of the same Ghosting Functor types we are encountering
3473  counts[demangle(typeid(*gf).name())]++;
3474  }
3475 
3476  for (const auto & pair : counts)
3477  info_strings.emplace_back(std::make_pair(
3478  "Default", pair.first + (pair.second > 1 ? " x " + std::to_string(pair.second) : "")));
3479  }
3480 
3481  // List the libMesh GhostingFunctors - Not that in libMesh all of the algebraic and coupling
3482  // Ghosting Functors are also attached to the mesh. This should catch them all.
3483  const auto & d_mesh = _action_warehouse.getDisplacedMesh();
3484  if (d_mesh)
3485  {
3486  // Let us use an ordered map to avoid stochastic console behaviors.
3487  // I believe we won't have many RMs, and there is no performance issue.
3488  // Deterministic behaviors are good for setting up regression tests
3489  std::map<std::string, unsigned int> counts;
3490 
3491  for (auto & gf : as_range(d_mesh->getMesh().ghosting_functors_begin(),
3492  d_mesh->getMesh().ghosting_functors_end()))
3493  {
3494  const auto * gf_ptr = dynamic_cast<const RelationshipManager *>(gf);
3495  if (!gf_ptr)
3496  // Count how many occurences of the same Ghosting Functor types we are encountering
3497  counts[demangle(typeid(*gf).name())]++;
3498  }
3499 
3500  for (const auto & pair : counts)
3501  info_strings.emplace_back(
3502  std::make_pair("Default",
3503  pair.first + (pair.second > 1 ? " x " + std::to_string(pair.second) : "") +
3504  " for DisplacedMesh"));
3505  }
3506 
3507  return info_strings;
3508 }
libMesh::MeshBase::ghosting_functors_begin
GhostingFunctorIterator ghosting_functors_begin() const
ActionWarehouse::getMesh
const std::shared_ptr< MooseMesh > & getMesh() const
Definition: ActionWarehouse.h:271
mesh
MeshBase & mesh
libMesh::MeshBase::ghosting_functors_end
GhostingFunctorIterator ghosting_functors_end() const
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
as_range
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Moose::stringify
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
demangle
std::string demangle(const char *name)
RelationshipManager
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
Definition: RelationshipManager.h:26
ActionWarehouse::getDisplacedMesh
const std::shared_ptr< MooseMesh > & getDisplacedMesh() const
Definition: ActionWarehouse.h:274
MooseApp::_relationship_managers
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1350

◆ 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_namethe old name for the parameter
new_namethe new name for the parameter

Definition at line 402 of file MooseBase.h.

403 {
404  // Most important: accept new parameter
405  if (isParamSetByUser(new_name) && !isParamValid(old_name))
406  return getParam<T>(new_name);
407  // Second most: accept old parameter
408  if (isParamValid(old_name) && !isParamSetByUser(new_name))
409  return getParam<T>(old_name);
410  // Third most: accept default for new parameter
411  if (isParamValid(new_name) && !isParamValid(old_name))
412  return getParam<T>(new_name);
413  // Refuse: no default, no value passed
414  if (!isParamValid(old_name) && !isParamValid(new_name))
415  mooseError("parameter '" + new_name +
416  "' is being retrieved without being set.\nDid you misspell it?");
417  // Refuse: both old and new parameters set by user
418  else
419  mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
420  old_name + "'");
421 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205

◆ getRestartableData() [1/2]

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

Return reference to the restartable data object.

Returns
A reference to the restartable data object

Definition at line 687 of file MooseApp.h.

687 { return _restartable_data; }
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242

◆ getRestartableData() [2/2]

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

Definition at line 688 of file MooseApp.h.

688 { return _restartable_data; }
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242

◆ getRestartableDataMap()

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

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

Definition at line 3543 of file MooseApp.C.

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

3544 {
3545  auto iter = _restartable_meta_data.find(name);
3546  if (iter == _restartable_meta_data.end())
3547  mooseError("Unable to find RestartableDataMap object for the supplied name '",
3548  name,
3549  "', did you call registerRestartableDataMapName in the application constructor?");
3550  return iter->second.first;
3551 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

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

Referenced by SetupDebugAction::act().

1033 { return _restartable_meta_data.begin(); }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542

◆ getRestartableDataMapEnd()

auto MooseApp::getRestartableDataMapEnd ( )
inline

Definition at line 1035 of file MooseApp.h.

Referenced by SetupDebugAction::act().

1035 { return _restartable_meta_data.end(); }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542

◆ getRestartableDataMapName()

const std::string & MooseApp::getRestartableDataMapName ( const RestartableDataMapName &  name) const
Returns
The output name for the restartable data with name name

Definition at line 3570 of file MooseApp.C.

Referenced by possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

3571 {
3572  const auto it = _restartable_meta_data.find(name);
3573  if (it == _restartable_meta_data.end())
3574  mooseError("MooseApp::getRestartableDataMapName: The name '", name, "' is not registered");
3575  return it->second.second;
3576 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ getRestartableMetaData()

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

Definition at line 2627 of file MooseApp.C.

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

2630 {
2631  if (tid != 0)
2632  mooseError(
2633  "The meta data storage for '", metaname, "' is not threaded, so the tid must be zero.");
2634 
2635  // Get metadata reference from RestartableDataMap and return a (non-const) reference to its value
2636  auto & restartable_data_map = getRestartableDataMap(metaname);
2637  RestartableDataValue * const data = restartable_data_map.findData(name);
2638  if (!data)
2639  mooseError("Unable to find RestartableDataValue object with name " + name +
2640  " in RestartableDataMap");
2641 
2642  return *data;
2643 }
MooseApp::getRestartableDataMap
RestartableDataMap & getRestartableDataMap(const RestartableDataMapName &name)
Return a reference to restartable data for the specific type flag.
Definition: MooseApp.C:3543
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
RestartableDataValue
Abstract definition of a RestartableData value.
Definition: RestartableData.h:31

◆ getRestartRecoverFileBase()

std::string MooseApp::getRestartRecoverFileBase ( ) const
inline

The file_base for the recovery file.

Definition at line 494 of file MooseApp.h.

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

494 { return _restart_recover_base; }
MooseApp::_restart_recover_base
std::string _restart_recover_base
The base name to restart/recover from. If blank then we will find the newest checkpoint file...
Definition: MooseApp.h:1336

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

Referenced by removeRelationshipManager().

3195 {
3196  auto outer_it = _template_to_clones.find(&template_rm);
3197  if (outer_it == _template_to_clones.end())
3198  mooseError("The template rm does not exist in our _template_to_clones map");
3199 
3200  auto & mesh_to_clone_map = outer_it->second;
3201  auto inner_it = mesh_to_clone_map.find(&mesh);
3202  if (inner_it == mesh_to_clone_map.end())
3203  mooseError("We should have the mesh key in our mesh");
3204 
3205  return *inner_it->second;
3206 }
MooseApp::_template_to_clones
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...
Definition: MooseApp.h:1602
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ getStartTime()

Real MooseApp::getStartTime ( ) const
inline
Returns
The start time

Definition at line 300 of file MooseApp.h.

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

300 { return _start_time; }
MooseApp::_start_time
Real _start_time
The time at which to start the simulation.
Definition: MooseApp.h:1208

◆ getSystemInfo()

const SystemInfo& MooseApp::getSystemInfo ( ) const
inline

Get SystemInfo object.

Returns
A pointer to the SystemInformation object

Definition at line 561 of file MooseApp.h.

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

561 { return _sys_info; }
MooseApp::_sys_info
SystemInfo _sys_info
System Information.
Definition: MooseApp.h:1236

◆ getVersion()

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

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

Definition at line 1260 of file MooseApp.C.

Referenced by getPrintableVersion().

1261 {
1262  return MOOSE_VERSION;
1263 }

◆ 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(); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::hasBase
bool hasBase() const
Definition: InputParameters.C:491

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

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

1002  {
1003  return _initial_backup != nullptr && *_initial_backup != nullptr;
1004  }
MooseApp::_initial_backup
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 ...
Definition: MooseApp.h:1611

◆ hasKokkosObjects()

bool MooseApp::hasKokkosObjects ( ) const
inline

Get whether there is any Kokkos object added by actions.

Returns
Whether there is any Kokkos object added by actions

Definition at line 1119 of file MooseApp.h.

Referenced by MooseMesh::update().

1119 { return _has_kokkos_objects; }
MooseApp::_has_kokkos_objects
bool _has_kokkos_objects
Flag whether there is any Kokkos object added by actions.
Definition: MooseApp.h:1650

◆ hasMeshGenerator()

bool MooseApp::hasMeshGenerator ( const MeshGeneratorName &  name) const
inline
Returns
Whether or not a mesh generator exists with the name name.

Definition at line 866 of file MooseApp.h.

867  {
868  return _mesh_generator_system.hasMeshGenerator(name);
869  }
MooseApp::_mesh_generator_system
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1570
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGeneratorSystem::hasMeshGenerator
bool hasMeshGenerator(const MeshGeneratorName &name) const
Definition: MeshGeneratorSystem.C:608

◆ hasOutputPosition()

bool MooseApp::hasOutputPosition ( ) const
inline

Whether or not an output position has been set.

Returns
True if it has

Definition at line 276 of file MooseApp.h.

Referenced by Exodus::output().

276 { return _output_position_set; }
MooseApp::_output_position_set
bool _output_position_set
Whether or not an output position has been set for this app.
Definition: MooseApp.h:1199

◆ hasRecoverFileBase()

bool MooseApp::hasRecoverFileBase ( ) const

Definition at line 1908 of file MooseApp.C.

1909 {
1910  mooseDeprecated("MooseApp::hasRecoverFileBase is deprecated, use "
1911  "MooseApp::hasRestartRecoverFileBase() instead.");
1912  return !_restart_recover_base.empty();
1913 }
MooseApp::_restart_recover_base
std::string _restart_recover_base
The base name to restart/recover from. If blank then we will find the newest checkpoint file...
Definition: MooseApp.h:1336
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314

◆ hasRelationshipManager()

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

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

Definition at line 3081 of file MooseApp.C.

3082 {
3083  return std::find_if(_relationship_managers.begin(),
3084  _relationship_managers.end(),
3085  [&name](const std::shared_ptr<RelationshipManager> & rm)
3086  { return rm->name() == name; }) != _relationship_managers.end();
3087 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::_relationship_managers
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1350

◆ hasRestartableDataMap()

bool MooseApp::hasRestartableDataMap ( const RestartableDataMapName &  name) const
Returns
Whether or not the restartable data has the given name registered.

Definition at line 3554 of file MooseApp.C.

3555 {
3556  return _restartable_meta_data.count(name);
3557 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ hasRestartableMetaData()

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

Definition at line 2617 of file MooseApp.C.

Referenced by MeshMetaDataInterface::hasMeshProperty().

2619 {
2620  auto it = _restartable_meta_data.find(metaname);
2621  if (it == _restartable_meta_data.end())
2622  return false;
2623  return it->second.first.hasData(name);
2624 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ hasRestartRecoverFileBase()

bool MooseApp::hasRestartRecoverFileBase ( ) const

Return true if the recovery file base is set.

Definition at line 1902 of file MooseApp.C.

1903 {
1904  return !_restart_recover_base.empty();
1905 }
MooseApp::_restart_recover_base
std::string _restart_recover_base
The base name to restart/recover from. If blank then we will find the newest checkpoint file...
Definition: MooseApp.h:1336

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

Referenced by removeRelationshipManager().

3187 {
3188  auto it = _template_to_clones.find(&template_rm);
3189  // C++ does short circuiting so we're safe here
3190  return (it != _template_to_clones.end()) && (it->second.find(&mesh) != it->second.end());
3191 }
MooseApp::_template_to_clones
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...
Definition: MooseApp.h:1602

◆ hasStartTime()

bool MooseApp::hasStartTime ( ) const
inline
Returns
Whether or not a start time has been programmatically set using setStartTime()

Definition at line 295 of file MooseApp.h.

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

295 { return _start_time_set; }
MooseApp::_start_time_set
bool _start_time_set
Whether or not an start time has been set.
Definition: MooseApp.h:1205

◆ header()

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

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

Definition at line 2989 of file MooseApp.C.

Referenced by restore(), and setupOptions().

2990 {
2991  return std::string("");
2992 }

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

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

1102  {
1103 #ifdef MOOSE_KOKKOS_ENABLED
1104 #ifdef MOOSE_ENABLE_KOKKOS_GPU
1105  return _has_kokkos_gpus;
1106 #else
1107  return true;
1108 #endif
1109 #else
1110  return false;
1111 #endif
1112  }
MooseApp::_has_kokkos_gpus
bool _has_kokkos_gpus
Flag whether every process has an associated Kokkos GPU.
Definition: MooseApp.h:1645

◆ 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
nameThe name of the parameter to test

Definition at line 205 of file MooseBase.h.

Referenced by SetupDebugAction::act(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), MFEMDomainSubMesh::buildSubMesh(), MFEMBoundarySubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), errorCheck(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), runInputFile(), runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

206  {
207  return _pars.isParamSetByUser(name);
208  }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
Definition: InputParameters.C:1228

◆ isParamValid()

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

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 199 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), CopyNodalVarsAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), SetAdaptivityOptionsAction::act(), AddVariableAction::act(), CreateDisplacedProblemAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), DiffusionPhysicsBase::addPostprocessors(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinerGenerator::CombinerGenerator(), FunctorAux::computeValue(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), GeneratedMeshGenerator::generate(), BlockDeletionGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), ParsedConvergence::initialSetup(), SolutionScalarAux::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionAux::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ParsedCurveGenerator::ParsedCurveGenerator(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), MooseMesh::prepare(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusII(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

199 { return _pars.isParamValid(name); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
InputParameters::isParamValid
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.
Definition: InputParameters.C: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 1884 of file MooseApp.C.

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

1885 {
1886  return _recover;
1887 }
MooseApp::_recover
bool _recover
Whether or not this is a recovery run.
Definition: MooseApp.h:1318

◆ isRestarting()

bool MooseApp::isRestarting ( ) const

Whether or not this is a "restart" calculation.

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

Definition at line 1890 of file MooseApp.C.

Referenced by SetupMeshAction::act(), FEProblemBase::checkICRestartError(), MultiApp::createApp(), EigenProblem::execute(), FileOutput::FileOutput(), FullSolveMultiApp::FullSolveMultiApp(), Eigenvalue::init(), FEProblemBase::initialSetup(), TransientBase::preExecute(), TimeSequenceStepperBase::setupSequence(), PhysicsBase::shouldCreateIC(), and TransientMultiApp::solveStep().

1891 {
1892  return _restart;
1893 }
MooseApp::_restart
bool _restart
Whether or not this is a restart run.
Definition: MooseApp.h:1321

◆ isSplitMesh()

bool MooseApp::isSplitMesh ( ) const

Whether or not this is a split mesh operation.

Definition at line 1896 of file MooseApp.C.

Referenced by MooseMesh::init().

1897 {
1898  return _split_mesh;
1899 }
MooseApp::_split_mesh
bool _split_mesh
Whether or not we are performing a split mesh operation (–split-mesh)
Definition: MooseApp.h:1324

◆ isUltimateMaster()

bool MooseApp::isUltimateMaster ( ) const
inline

Whether or not this app is the ultimate master app.

(ie level == 0)

Definition at line 820 of file MooseApp.h.

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

820 { return !_multiapp_level; }
MooseApp::_multiapp_level
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
Definition: MooseApp.h:1555

◆ libNameToAppName()

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

Converts a library name to an application name:

Definition at line 2553 of file MooseApp.C.

2554 {
2555  std::string app_name(library_name);
2556 
2557  // Strip off the leading "lib" and trailing ".la"
2558  if (pcrecpp::RE("lib(.+?)(?:-\\w+)?\\.la").Replace("\\1", &app_name) == 0)
2559  mooseError("Invalid library name: ", app_name);
2560 
2561  return MooseUtils::underscoreToCamelCase(app_name, true);
2562 }
MooseUtils::underscoreToCamelCase
std::string underscoreToCamelCase(const std::string &underscore_name, bool leading_upper_case)
Definition: MooseUtils.C:580
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

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

Referenced by dynamicRegistration().

2799 {
2800  std::string line;
2801  std::string dl_lib_filename;
2802 
2803  // This RE looks for absolute path libtool filenames (i.e. begins with a slash and ends with a
2804  // .la)
2805  pcrecpp::RE re_deps("(/\\S*\\.la)");
2806 
2807  std::ifstream la_handle(library_filename.c_str());
2808  if (la_handle.is_open())
2809  {
2810  while (std::getline(la_handle, line))
2811  {
2812  // Look for the system dependent dynamic library filename to open
2813  if (line.find("dlname=") != std::string::npos)
2814  // Magic numbers are computed from length of this string "dlname=' and line minus that
2815  // string plus quotes"
2816  dl_lib_filename = line.substr(8, line.size() - 9);
2817 
2818  if (line.find("dependency_libs=") != std::string::npos)
2819  {
2820  if (load_dependencies)
2821  {
2822  pcrecpp::StringPiece input(line);
2823  pcrecpp::StringPiece depend_library;
2824  while (re_deps.FindAndConsume(&input, &depend_library))
2825  // Recurse here to load dependent libraries in depth-first order
2826  loadLibraryAndDependencies(depend_library.as_string(), params, load_dependencies);
2827  }
2828 
2829  // There's only one line in the .la file containing the dependency libs so break after
2830  // finding it
2831  break;
2832  }
2833  }
2834  la_handle.close();
2835  }
2836 
2837  // This should only occur if we have static linkage.
2838  if (dl_lib_filename.empty())
2839  return;
2840 
2841  const auto & [dir, file_name] = MooseUtils::splitFileName(library_filename);
2842 
2843  // Time to load the library, First see if we've already loaded this particular dynamic library
2844  // 1) make sure we haven't already loaded this library
2845  // AND 2) make sure we have a library name (we won't for static linkage)
2846  // Note: Here was are going to assume uniqueness based on the filename alone. This has significant
2847  // implications for applications that have "diamond" inheritance of libraries (usually
2848  // modules). We will only load one of those libraries, versions be damned.
2849  auto dyn_lib_it = _lib_handles.find(file_name);
2850  if (dyn_lib_it == _lib_handles.end())
2851  {
2852  // Assemble the actual filename using the base path of the *.la file and the dl_lib_filename
2853  const auto dl_lib_full_path = MooseUtils::pathjoin(dir, dl_lib_filename);
2854 
2855  MooseUtils::checkFileReadable(dl_lib_full_path, false, /*throw_on_unreadable=*/true);
2856 
2857 #ifdef LIBMESH_HAVE_DLOPEN
2858  void * const lib_handle = dlopen(dl_lib_full_path.c_str(), RTLD_LAZY);
2859 #else
2860  void * const lib_handle = nullptr;
2861 #endif
2862 
2863  if (!lib_handle)
2864  mooseError("The library file \"",
2865  dl_lib_full_path,
2866  "\" exists and has proper permissions, but cannot by dynamically loaded.\nThis "
2867  "generally means that the loader was unable to load one or more of the "
2868  "dependencies listed in the supplied library (see otool or ldd).\n",
2869  dlerror());
2870 
2871  DynamicLibraryInfo lib_info;
2872  lib_info.library_handle = lib_handle;
2873  lib_info.full_path = library_filename;
2874 
2875  auto insert_ret = _lib_handles.insert(std::make_pair(file_name, lib_info));
2876  mooseAssert(insert_ret.second == true, "Error inserting into lib_handles map");
2877 
2878  dyn_lib_it = insert_ret.first;
2879  }
2880 
2881  // Library has been loaded, check to see if we've called the requested registration method
2882  const auto registration_method = params.get<std::string>("registration_method");
2883  auto & entry_sym_from_curr_lib = dyn_lib_it->second.entry_symbols;
2884 
2885  if (entry_sym_from_curr_lib.find(registration_method) == entry_sym_from_curr_lib.end())
2886  {
2887  // get the pointer to the method in the library. The dlsym()
2888  // function returns a null pointer if the symbol cannot be found,
2889  // we also explicitly set the pointer to NULL if dlsym is not
2890  // available.
2891 #ifdef LIBMESH_HAVE_DLOPEN
2892  void * registration_handle =
2893  dlsym(dyn_lib_it->second.library_handle, registration_method.c_str());
2894 #else
2895  void * registration_handle = nullptr;
2896 #endif
2897 
2898  if (registration_handle)
2899  {
2900  switch (params.get<RegistrationType>("reg_type"))
2901  {
2902  case APPLICATION:
2903  {
2904  using register_app_t = void (*)();
2905  register_app_t * const reg_ptr = reinterpret_cast<register_app_t *>(&registration_handle);
2906  (*reg_ptr)();
2907  break;
2908  }
2909  case REGALL:
2910  {
2911  using register_app_t = void (*)(Factory *, ActionFactory *, Syntax *);
2912  register_app_t * const reg_ptr = reinterpret_cast<register_app_t *>(&registration_handle);
2913  (*reg_ptr)(params.get<Factory *>("factory"),
2914  params.get<ActionFactory *>("action_factory"),
2915  params.get<Syntax *>("syntax"));
2916  break;
2917  }
2918  default:
2919  mooseError("Unhandled RegistrationType");
2920  }
2921 
2922  entry_sym_from_curr_lib.insert(registration_method);
2923  }
2924  else
2925  {
2926 
2927 #if defined(DEBUG) && defined(LIBMESH_HAVE_DLOPEN)
2928  // We found a dynamic library that doesn't have a dynamic
2929  // registration method in it. This shouldn't be an error, so
2930  // we'll just move on.
2931  if (!registration_handle)
2932  mooseWarning("Unable to find extern \"C\" method \"",
2933  registration_method,
2934  "\" in library: ",
2935  dyn_lib_it->first,
2936  ".\n",
2937  "This doesn't necessarily indicate an error condition unless you believe that "
2938  "the method should exist in that library.\n",
2939  dlerror());
2940 #endif
2941  }
2942  }
2943 }
libMesh::Parameters::get
const T & get(std::string_view) const
MooseApp::loadLibraryAndDependencies
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 applicatio...
Definition: MooseApp.C:2796
ActionFactory
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:48
MooseApp::RegistrationType
RegistrationType
Enumeration for holding the valid types of dynamic registrations allowed.
Definition: MooseApp.h:1545
MooseApp::_lib_handles
std::unordered_map< std::string, DynamicLibraryInfo > _lib_handles
The library archive (name only), registration method and the handle to the method.
Definition: MooseApp.h:1371
MooseUtils::pathjoin
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:59
MooseBase::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299
Syntax
Holding syntax for parsing input files.
Definition: Syntax.h:21
void
class infix_ostream_iterator if void
Definition: InfixIterator.h:26
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseUtils::checkFileReadable
bool checkFileReadable(const std::string &filename, bool check_line_endings, bool throw_on_unreadable, bool check_for_git_lfs_pointer)
Definition: MooseUtils.C:254

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

Referenced by SetupRecoverFileBaseAction::act().

2662 {
2663  for (const auto & name_map_pair : _restartable_meta_data)
2664  possiblyLoadRestartableMetaData(name_map_pair.first, folder_base);
2665 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
MooseApp::possiblyLoadRestartableMetaData
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.
Definition: MooseApp.C:2646

◆ masterDisplacedMesh()

const MooseMesh* MooseApp::masterDisplacedMesh ( ) const
inline

Returns a pointer to the master displaced mesh.

Definition at line 835 of file MooseApp.h.

Referenced by SetupMeshAction::act().

835 { return _master_displaced_mesh; }
MooseApp::_master_displaced_mesh
const MooseMesh *const _master_displaced_mesh
The displaced mesh from master app.
Definition: MooseApp.h:1567

◆ masterMesh()

const MooseMesh* MooseApp::masterMesh ( ) const
inline

Returns a pointer to the master mesh.

Definition at line 830 of file MooseApp.h.

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

830 { return _master_mesh; }
MooseApp::_master_mesh
const MooseMesh *const _master_mesh
The mesh from master app.
Definition: MooseApp.h:1564

◆ messagePrefix()

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.

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

257  {
258  return messagePrefix(_pars, hit_prefix);
259  }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

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

Referenced by possiblyLoadRestartableMetaData(), and writeRestartableMetaData().

3164 {
3165  return RestartableDataIO::restartableDataFolder(folder_base /
3166  std::filesystem::path("meta_data" + map_suffix));
3167 }
RestartableDataIO::restartableDataFolder
static std::filesystem::path restartableDataFolder(const std::filesystem::path &folder_base)
Definition: RestartableDataIO.C:72

◆ mooseDeprecated()

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

Definition at line 314 of file MooseBase.h.

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

315  {
316  moose::internal::mooseDeprecatedStream(
317  _console, false, true, messagePrefix(true), std::forward<Args>(args)...);
318  }
moose::internal::mooseDeprecatedStream
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, Args &&... args)
Definition: MooseError.h:265
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

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

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

280  {
281  callMooseError(moose::internal::formatMooseDocumentedError(
282  repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
283  /* with_prefix = */ true);
284  }
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105
moose::internal::formatMooseDocumentedError
std::string formatMooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
Formats a documented error.
Definition: MooseError.C:128

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

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), CheckIntegrityAction::act(), SetupMeshCompleteAction::act(), CreateExecutionerAction::act(), AddBoundsVectorsAction::act(), AddMeshGeneratorAction::act(), AutoCheckpointAction::act(), AddFVICAction::act(), AddICAction::act(), AddVectorPostprocessorAction::act(), InitProblemAction::act(), CheckFVBCAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), ChainControlSetupAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADArrayReaction::ADArrayReaction(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), addExecutor(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInitialCondition(), PhysicsComponentInterface::addInitialConditionsFromComponents(), FEProblemBase::addInterfaceKernel(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), MFEMProblem::addMaterial(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addScalarKernel(), WebServerControl::addServerAction(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), NEML2ModelExecutor::applyPredictor(), appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), attachRelationshipManagers(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelBase::AuxKernelBase(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularInterface::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), DefaultMultiAppFixedPointConvergence::checkIterationType(), DefaultNonlinearConvergence::checkIterationType(), DefaultSteadyStateConvergence::checkIterationType(), ExplicitTimeIntegrator::checkLinearConvergence(), checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), checkReservedCapability(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MFEMSolverBase::checkSpectralEquivalence(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), ADArrayNodalKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), IPHDGBC::computeQpResidual(), KernelValue::computeQpResidual(), TorchScriptMaterial::computeQpValues(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), HDGKernel::computeResidualAndJacobianOnSide(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), KernelScalarBase::computeScalarOffDiagJacobian(), ADKernelScalarBase::computeScalarQpResidual(), ADMortarScalarBase::computeScalarQpResidual(), MortarScalarBase::computeScalarQpResidual(), KernelScalarBase::computeScalarQpResidual(), TimeStepper::computeStep(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), createExecutors(), AddVariableAction::createInitialConditionAction(), createRMFromTemplateAndInit(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyByName(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), determineLibtorchDeviceType(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), dynamicAllRegistration(), dynamicAppRegistration(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< false >::errorNoFaceInfo(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), FixedPointSolve::examineFixedPointConvergence(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RealToBoolChainControl::execute(), RestartableDataReporter::execute(), DiscreteElementUserObject::execute(), PositionsFunctorValueSampler::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), NodalValueSampler::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), ElementQualityChecker::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), InterfaceQpUserObjectBase::execute(), TransientBase::execute(), LeastSquaresFit::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFitHistory::execute(), WebServerControl::execute(), Eigenvalue::execute(), TimeExtremeValue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), executeExecutioner(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyNodalUniqueID::finalize(), ParsedVectorReporter::finalize(), VerifyElementUniqueID::finalize(), ParsedVectorVectorRealReductionReporter::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), DiscreteVariableResidualNorm::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), finalizeRestore(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementSubdomainModifierBase::gatherPatchElements(), Boundary2DDelaunayGenerator::General2DDelaunay(), ElementOrderConversionGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromPointsGenerator::generate(), StitchMeshGenerator::generate(), GeneratedMeshGenerator::generate(), FlipSidesetGenerator::generate(), CoarsenBlockGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BreakMeshByBlockGenerator::generate(), MeshDiagnosticsGenerator::generate(), ParsedGenerateNodeset::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), AdvancedExtruderGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getAxisymmetricRadialCoord(), NEML2BatchIndexGenerator::getBatchIndex(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), MooseMesh::getCoarseningMap(), NodalPatchRecoveryBase::getCoefficients(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), FEProblemBase::getConvergence(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PropertyReadFile::getData(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), getExecutor(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVMatsAndDependencies(), MooseMesh::getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), FEProblemBase::getKokkosFunction(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), NEML2ModelExecutor::getOutput(), NEML2ModelExecutor::getOutputDerivative(), NEML2ModelExecutor::getOutputParameterDerivative(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), getRestartableDataMap(), getRestartableDataMapName(), getRestartableMetaData(), getRMClone(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSteadyStateConvergenceName(), MooseMesh::getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), TransientBase::getTimeIntegratorNames(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorComponent::getValue(), NumRelationshipManagers::getValue(), Residual::getValue(), SideAverageValue::getValue(), JSONFileReader::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), ExplicitTimeIntegrator::init(), TransientBase::init(), FEProblem::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), ReporterPositions::initialize(), DistributedPositions::initialize(), TransformedPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), PiecewiseLinearBase::initialSetup(), ChainControlDataPostprocessor::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVDiffusion::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), ExplicitTimeIntegrator::initialSetup(), SolutionAux::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), ElementSubdomainModifierBase::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), InternalSideIndicatorBase::InternalSideIndicatorBase(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), loadLibraryAndDependencies(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseLinearVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), MassMatrix::MassMatrix(), Material::Material(), MaterialRealTensorValueAuxTempl< is_ad >::MaterialRealTensorValueAuxTempl(), MaterialRealVectorValueAuxTempl< T, is_ad, is_functor >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), MFEMCrossProductAux::MFEMCrossProductAux(), MFEMDotProductAux::MFEMDotProductAux(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), outputMachineReadableData(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), PiecewiseTabularInterface::PiecewiseTabularInterface(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), AStableDirk4::postResidual(), LStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), FunctorKernel::precomputeQpResidual(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), ElementSubdomainModifierBase::prepareVariableForReinitialization(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), registerRestartableData(), registerRestartableNameWithFilter(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), MFEMTransient::relativeSolutionDifferenceNorm(), removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), run(), runInputs(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), MooseMesh::setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), setMFEMDevice(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), AddPeriodicBCAction::setPeriodicVars(), MFEMSolverBase::setPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), TimePeriodBase::setupTimes(), IntegratedBCBase::shouldApply(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointAverage::spatialValue(), NearestPointIntegralVariablePostprocessor::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), DisplacedProblem::systemBaseLinear(), Console::systemInfoFlags(), FEProblemBase::systemNumForVariable(), TerminateChainControl::terminate(), Terminator::Terminator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeExtremeValue::TimeExtremeValue(), Function::timeIntegral(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), MooseBase::uniqueName(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObjectBase::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), MFEMHypreAMS::updateSolver(), MFEMHypreADS::updateSolver(), MFEMHyprePCG::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreGMRES::updateSolver(), MFEMSuperLU::updateSolver(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointAverage::userObjectValue(), NearestPointIntegralVariablePostprocessor::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), AddVariableAction::variableType(), VariableValueVolumeHistogram::VariableValueVolumeHistogram(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), VectorNodalBC::VectorNodalBC(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), VTKOutput::VTKOutput(), WebServerControl::WebServerControl(), writeRestartableMetaData(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

272  {
273  callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
274  }
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

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

291  {
292  callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
293  }
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

◆ mooseInfo()

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

Definition at line 321 of file MooseBase.h.

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

322  {
323  moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
324  }
moose::internal::mooseInfoStream
void mooseInfoStream(S &oss, Args &&... args)
Definition: MooseError.h:258
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

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

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

300  {
301  moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
302  }
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:210
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

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

309  {
310  moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
311  }
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:210
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31

◆ multiAppLevel()

unsigned int MooseApp::multiAppLevel ( ) const
inline

The MultiApp Level.

Returns
The current number of levels from the master app

Definition at line 809 of file MooseApp.h.

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

809 { return _multiapp_level; }
MooseApp::_multiapp_level
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
Definition: MooseApp.h:1555

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

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

815 { return _multiapp_number; }
MooseApp::_multiapp_number
unsigned int _multiapp_number
Numbering in all the sub-apps on the same level.
Definition: MooseApp.h:1558

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

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

104  {
105  mooseAssert(_name.size(), "Empty name");
106  return _name;
107  }
MooseBase::_name
const std::string & _name
The name of this class.
Definition: MooseBase.h:363

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

Referenced by runInputFile(), and setupOptions().

3655 {
3656  // Bool parameter, just to screen
3657  if (_pars.have_parameter<bool>(param))
3658  {
3659  Moose::out << start_marker << data << end_marker << std::endl;
3660  return;
3661  }
3662 
3663  // String parameter, to file
3664  const auto & filename = getParam<std::string>(param);
3665  // write to file
3666  std::ofstream out(filename.c_str());
3667  if (out.is_open())
3668  {
3669  std::ofstream out(filename.c_str());
3670  out << data << std::flush;
3671  out.close();
3672  }
3673  else
3674  mooseError("Unable to open file `", filename, "` for writing ", param, " data to it.");
3675 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition: InputParameters.h:2329
out
OStreamProxy out
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ 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 439 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayReactionNodalKernelTempl< is_ad >::ArrayReactionNodalKernelTempl(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), checkComponent(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), FunctorAux::computeValue(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ExtraNodesetGenerator::generate(), AddMetaDataGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementsToTetrahedronsConverter::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BlockDeletionGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), KokkosBoundNodalKernel< KokkosUpperBoundNodalKernel >::KokkosBoundNodalKernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMDotProductAux::MFEMDotProductAux(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMSumAux::MFEMSumAux(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupParameterDerivativeMappings(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), TimeSequenceStepperBase::updateSequence(), UserObject::UserObject(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), ParsedMaterialBase::validateVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

440 {
441  _pars.paramError(param, std::forward<Args>(args)...);
442 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::paramError
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available...
Definition: InputParameters.h:2437

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

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), SetupDebugAction::act(), CSGOnlyAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), MFEMProblem::addAuxVariable(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MFEMProblem::addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), ElementSubdomainModifierBase::extrapolatePolynomial(), FEProblem::FEProblem(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), AuxKernelBase::getVariableHelper(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), MeshGeneratorSystem::hasDataDrivenAllowed(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseObject::isKokkosObject(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MFEMCGSolver::MFEMCGSolver(), MFEMGMRESSolver::MFEMGMRESSolver(), MFEMHypreADS::MFEMHypreADS(), MFEMHypreAMS::MFEMHypreAMS(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMHypreFGMRES::MFEMHypreFGMRES(), MFEMHypreGMRES::MFEMHypreGMRES(), MFEMHyprePCG::MFEMHyprePCG(), MFEMOperatorJacobiSmoother::MFEMOperatorJacobiSmoother(), MFEMSuperLU::MFEMSuperLU(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MooseServer::parseDocumentForDiagnostics(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), and ~MooseApp().

131 { return _pars; }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366

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

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

454 {
455  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
456 }
InputParameters::paramMessage
std::string paramMessage(const std::string &param, Args... args) const
Definition: InputParameters.h:2428
MooseBase::mooseInfo
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:321
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366

◆ 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 446 of file MooseBase.h.

447 {
448  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
449 }
InputParameters::paramMessage
std::string paramMessage(const std::string &param, Args... args) const
Definition: InputParameters.h:2428
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseBase::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299

◆ parser() [1/2]

const Parser & MooseApp::parser ( ) const
Returns
The Parser

Definition at line 2070 of file MooseApp.C.

Referenced by ActionFactory::create().

2071 {
2072  mooseAssert(_parser, "Not set");
2073  return *_parser;
2074 }
MooseApp::_parser
const std::shared_ptr< Parser > _parser
Parser for parsing the input file (owns the root hit node)
Definition: MooseApp.h:1230

◆ parser() [2/2]

Parser & MooseApp::parser ( )

Definition at line 2077 of file MooseApp.C.

2078 {
2079  return const_cast<Parser &>(std::as_const(*this).parser());
2080 }
Parser
Class for parsing input files.
Definition: Parser.h:87

◆ perfGraph()

PerfGraph& MooseApp::perfGraph ( )
inline

Get the PerfGraph for this app.

Definition at line 173 of file MooseApp.h.

Referenced by PerfGraphInterface::perfGraph().

173 { return _perf_graph; }
MooseApp::_perf_graph
PerfGraph & _perf_graph
The PerfGraph object for this application (recoverable)
Definition: MooseApp.h:1251

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

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

2648 {
2649  const auto & map_name = getRestartableDataMapName(name);
2650  const auto meta_data_folder_base = metaDataFolderBase(folder_base, map_name);
2651  if (RestartableDataReader::isAvailable(meta_data_folder_base))
2652  {
2653  RestartableDataReader reader(*this, getRestartableDataMap(name), forceRestart());
2654  reader.setErrorOnLoadWithDifferentNumberOfProcessors(false);
2655  reader.setInput(meta_data_folder_base);
2656  reader.restore();
2657  }
2658 }
RestartableDataReader
Reader for restartable data written by the RestartableDataWriter.
Definition: RestartableDataReader.h:23
MooseApp::metaDataFolderBase
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)
Definition: MooseApp.C:3162
MooseApp::forceRestart
bool forceRestart() const
Whether or not we are forcefully restarting (allowing the load of potentially incompatibie checkpoint...
Definition: MooseApp.h:1068
MooseApp::getRestartableDataMap
RestartableDataMap & getRestartableDataMap(const RestartableDataMapName &name)
Return a reference to restartable data for the specific type flag.
Definition: MooseApp.C:3543
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::getRestartableDataMapName
const std::string & getRestartableDataMapName(const RestartableDataMapName &name) const
Definition: MooseApp.C:3570
RestartableDataReader::isAvailable
static bool isAvailable(const std::filesystem::path &folder_base)
Definition: RestartableDataReader.C:302

◆ postRestore()

virtual void MooseApp::postRestore ( const bool  )
inlinevirtual

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

Parameters
for_restartWhether this restoration is explicitly for the first restoration of restart data

Definition at line 773 of file MooseApp.h.

Referenced by restore().

773 {}

◆ preBackup()

virtual void MooseApp::preBackup ( )
inlinevirtual

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

Definition at line 739 of file MooseApp.h.

Referenced by backup().

739 {}

◆ processor_id()

processor_id_type MooseApp::processor_id ( ) const
inline

Returns the MPI processor ID of the current processor.

Definition at line 411 of file MooseApp.h.

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

411 { return _comm->rank(); }
MooseApp::_comm
const std::shared_ptr< libMesh::Parallel::Communicator > _comm
The MPI communicator this App is going to use.
Definition: MooseApp.h:1190

◆ 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 the parameter is not valid, nullptr will be returned

Parameters
nameThe name of the parameter
Returns
A pointer to the parameter value, if it exists

Definition at line 395 of file MooseBase.h.

396 {
397  return isParamValid(name) ? &getParam<T>(name) : nullptr;
398 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199

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

168 { return _rank_map; }
MooseApp::_rank_map
const RankMap _rank_map
The RankMap is a useful object for determining how the processes are laid out on the physical hardwar...
Definition: MooseApp.h:1257

◆ 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_nameThe name of the executor currently needing to be built
possible_rootsThe names of executors that are currently candidates for being the root

Definition at line 2083 of file MooseApp.C.

Referenced by createExecutors().

2086 {
2087  // Did we already make this one?
2088  if (_executors.find(current_executor_name) != _executors.end())
2089  return;
2090 
2091  // Is this one already on the current branch (i.e. there is a cycle)
2092  if (std::find(current_branch.begin(), current_branch.end(), current_executor_name) !=
2093  current_branch.end())
2094  {
2095  std::stringstream exec_names_string;
2096 
2097  auto branch_it = current_branch.begin();
2098 
2099  exec_names_string << *branch_it++;
2100 
2101  for (; branch_it != current_branch.end(); ++branch_it)
2102  exec_names_string << ", " << *branch_it;
2103 
2104  exec_names_string << ", " << current_executor_name;
2105 
2106  mooseError("Executor cycle detected: ", exec_names_string.str());
2107  }
2108 
2109  current_branch.push_back(current_executor_name);
2110 
2111  // Build the dependencies first
2112  const auto & params = *_executor_params[current_executor_name].second;
2113 
2114  for (const auto & param : params)
2115  {
2116  if (params.have_parameter<ExecutorName>(param.first))
2117  {
2118  const auto & dependency_name = params.get<ExecutorName>(param.first);
2119 
2120  possible_roots.remove(dependency_name);
2121 
2122  if (!dependency_name.empty())
2123  recursivelyCreateExecutors(dependency_name, possible_roots, current_branch);
2124  }
2125  }
2126 
2127  // Add this Executor
2128  const auto & type = _executor_params[current_executor_name].first;
2129  addExecutor(type, current_executor_name, params);
2130 
2131  current_branch.pop_back();
2132 }
Moose::Kokkos::Utils::find
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:42
MooseApp::_executor_params
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> ...
Definition: MooseApp.h:1271
MooseApp::recursivelyCreateExecutors
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.
Definition: MooseApp.C:2083
MooseApp::_executors
std::map< std::string, std::shared_ptr< Executor > > _executors
Pointers to all of the Executors for this run.
Definition: MooseApp.h:1266
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseApp::addExecutor
void addExecutor(const std::string &type, const std::string &name, const InputParameters &params)
Definition: MooseApp.C:2050
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

◆ registerCapabilities()

void MooseApp::registerCapabilities ( )
private

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

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

◆ registerInterfaceObject()

template<class T >
void MooseApp::registerInterfaceObject ( T &  interface)

Registers an interface object for accessing with getInterfaceObjects.

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

Definition at line 1656 of file MooseApp.h.

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

1657 {
1658  static_assert(!std::is_base_of<MooseObject, T>::value, "T is not an interface");
1659 
1660  InterfaceRegistryObjects<T> * registry = nullptr;
1661  auto it = _interface_registry.find(typeid(T));
1662  if (it == _interface_registry.end())
1663  {
1664  auto new_registry = std::make_unique<InterfaceRegistryObjects<T>>();
1665  registry = new_registry.get();
1666  _interface_registry.emplace(typeid(T), std::move(new_registry));
1667  }
1668  else
1669  registry = static_cast<InterfaceRegistryObjects<T> *>(it->second.get());
1670 
1671  mooseAssert(std::count(registry->_objects.begin(), registry->_objects.end(), &interface) == 0,
1672  "Interface already registered");
1673  registry->_objects.push_back(&interface);
1674 }
Moose::ParameterRegistration::detail::registry
static Moose::ParameterRegistry & registry
Definition: ParameterRegistration.C:53
MooseApp::_interface_registry
std::map< std::type_index, std::unique_ptr< InterfaceRegistryObjectsBase > > _interface_registry
Registration for interface objects.
Definition: MooseApp.h:1605
Moose::ParameterRegistry::get
static ParameterRegistry & get()
Get the singleton registry.
Definition: ParameterRegistry.C:17

◆ registerRestartableData() [1/2]

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

Definition at line 2565 of file MooseApp.C.

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

2569 {
2570  if (!metaname.empty() && tid != 0)
2571  mooseError(
2572  "The meta data storage for '", metaname, "' is not threaded, so the tid must be zero.");
2573 
2574  mooseAssert(metaname.empty() ||
2575  _restartable_meta_data.find(metaname) != _restartable_meta_data.end(),
2576  "The desired meta data name does not exist: " + metaname);
2577 
2578  // Select the data store for saving this piece of restartable data (mesh or everything else)
2579  auto & data_map =
2580  metaname.empty() ? _restartable_data[tid] : _restartable_meta_data[metaname].first;
2581 
2582  RestartableDataValue * stored_data = data_map.findData(data->name());
2583  if (stored_data)
2584  {
2585  if (data->typeId() != stored_data->typeId())
2586  mooseError("Type mismatch found in RestartableData registration of '",
2587  data->name(),
2588  "'\n\n Stored type: ",
2589  stored_data->type(),
2590  "\n New type: ",
2591  data->type());
2592  }
2593  else
2594  stored_data = &data_map.addData(std::move(data));
2595 
2596  if (!read_only)
2597  stored_data->setDeclared({});
2598 
2599  return *stored_data;
2600 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
RestartableDataValue::typeId
virtual const std::type_info & typeId() const =0
The type ID of the underlying data.
MooseApp::_restartable_data
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1242
RestartableDataValue::type
virtual std::string type() const =0
String identifying the type of parameter stored.
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
RestartableDataValue::setDeclared
void setDeclared(const SetDeclaredKey)
Sets that this restartable value has been declared.
Definition: RestartableData.C:18
RestartableDataValue
Abstract definition of a RestartableData value.
Definition: RestartableData.h:31

◆ registerRestartableData() [2/2]

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

◆ registerRestartableDataMapName()

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

Reserve a location for storing custom RestartableDataMap objects.

This should be called in the constructor of an application.

Parameters
nameA key to use for accessing the data object
suffixThe 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 3560 of file MooseApp.C.

3561 {
3562  if (!suffix.empty())
3563  std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
3564  suffix.insert(0, "_");
3565  _restartable_meta_data.emplace(
3566  std::make_pair(name, std::make_pair(RestartableDataMap(), suffix)));
3567 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
RestartableDataMap
Storage for restartable data that is ordered based on insertion order.
Definition: RestartableDataMap.h:27
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ 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
nameThe full (unique) name.
filterThe filter name where to direct the name

Definition at line 1916 of file MooseApp.C.

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

1918 {
1919  using Moose::RESTARTABLE_FILTER;
1920  switch (filter)
1921  {
1922  case RESTARTABLE_FILTER::RECOVERABLE:
1923  _recoverable_data_names.insert(name);
1924  break;
1925  default:
1926  mooseError("Unknown filter");
1927  }
1928 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
Moose::RESTARTABLE_FILTER
RESTARTABLE_FILTER
The filter type applied to a particular piece of "restartable" data.
Definition: MooseTypes.h:840
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::_recoverable_data_names
DataNames _recoverable_data_names
Data names that will only be read from the restart file during RECOVERY.
Definition: MooseApp.h:1248

◆ 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_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
Returns
The ID of the section - use when starting timing

Definition at line 53 of file PerfGraphInterface.C.

55 {
56  const auto timed_section_name = timedSectionName(section_name);
57  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
58  return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
59  else
60  return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
61 }
moose::internal::PerfGraphRegistry::registerSection
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
Definition: PerfGraphRegistry.C:34
PerfGraphInterface::timedSectionName
std::string timedSectionName(const std::string &section_name) const
Definition: PerfGraphInterface.C:47
moose::internal::PerfGraphRegistry::sectionID
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID The name of the section.
Definition: PerfGraphRegistry.h:111
moose::internal::getPerfGraphRegistry
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.
Definition: PerfGraphRegistry.C:20

◆ 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_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
live_messageThe message to be printed to the screen during execution
print_dotsWhether or not progress dots should be printed for this section
Returns
The ID of the section - use when starting timing

Definition at line 64 of file PerfGraphInterface.C.

68 {
69  const auto timed_section_name = timedSectionName(section_name);
70  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
71  return moose::internal::getPerfGraphRegistry().registerSection(
72  timedSectionName(section_name), level, live_message, print_dots);
73  else
74  return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
75 }
moose::internal::PerfGraphRegistry::registerSection
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
Definition: PerfGraphRegistry.C:34
PerfGraphInterface::timedSectionName
std::string timedSectionName(const std::string &section_name) const
Definition: PerfGraphInterface.C:47
moose::internal::PerfGraphRegistry::sectionID
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID The name of the section.
Definition: PerfGraphRegistry.h:111
moose::internal::getPerfGraphRegistry
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.
Definition: PerfGraphRegistry.C:20

◆ relationshipManagers()

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

Return the container of relationship managers.

Definition at line 1017 of file MooseApp.h.

Referenced by NumRelationshipManagers::getValue().

1018  {
1019  return _relationship_managers;
1020  }
MooseApp::_relationship_managers
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1350

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

Referenced by addRelationshipManager().

3210 {
3211  auto * const mesh = _action_warehouse.mesh().get();
3212  if (!mesh)
3213  mooseError("The MooseMesh should exist");
3214 
3215  const MeshBase * const undisp_lm_mesh = mesh->getMeshPtr();
3216  RelationshipManager * undisp_clone = nullptr;
3217  if (undisp_lm_mesh && hasRMClone(*rm, *undisp_lm_mesh))
3218  {
3219  undisp_clone = &getRMClone(*rm, *undisp_lm_mesh);
3220  const_cast<MeshBase *>(undisp_lm_mesh)->remove_ghosting_functor(*undisp_clone);
3221  }
3222 
3223  auto & displaced_mesh = _action_warehouse.displacedMesh();
3224  MeshBase * const disp_lm_mesh = displaced_mesh ? &displaced_mesh->getMesh() : nullptr;
3225  RelationshipManager * disp_clone = nullptr;
3226  if (disp_lm_mesh && hasRMClone(*rm, *disp_lm_mesh))
3227  {
3228  disp_clone = &getRMClone(*rm, *disp_lm_mesh);
3229  disp_lm_mesh->remove_ghosting_functor(*disp_clone);
3230  }
3231 
3232  if (_executioner)
3233  {
3234  auto & problem = feProblem();
3235  if (undisp_clone)
3236  {
3237  problem.removeAlgebraicGhostingFunctor(*undisp_clone);
3238  problem.removeCouplingGhostingFunctor(*undisp_clone);
3239  }
3240 
3241  auto * dp = problem.getDisplacedProblem().get();
3242  if (dp && disp_clone)
3243  dp->removeAlgebraicGhostingFunctor(*disp_clone);
3244  }
3245 
3246  _factory.releaseSharedObjects(*rm);
3247  _relationship_managers.erase(rm);
3248 }
MooseApp::hasRMClone
bool hasRMClone(const RelationshipManager &template_rm, const MeshBase &mesh) const
Definition: MooseApp.C:3186
ActionWarehouse::displacedMesh
std::shared_ptr< MooseMesh > & displacedMesh()
Definition: ActionWarehouse.h:273
MooseApp::getRMClone
RelationshipManager & getRMClone(const RelationshipManager &template_rm, const MeshBase &mesh) const
Return the relationship manager clone originally created from the provided template relationship mana...
Definition: MooseApp.C:3194
libMesh::MeshBase::remove_ghosting_functor
void remove_ghosting_functor(GhostingFunctor &ghosting_functor)
mesh
MeshBase & mesh
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
MooseApp::feProblem
FEProblemBase & feProblem() const
Definition: MooseApp.C:2043
ActionWarehouse::mesh
std::shared_ptr< MooseMesh > & mesh()
Definition: ActionWarehouse.h:270
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
RelationshipManager
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
Definition: RelationshipManager.h:26
MooseApp::_relationship_managers
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1350
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::_factory
Factory _factory
Definition: MooseApp.h:1298

◆ restartFolderBase()

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

The file suffix for restartable data.

Definition at line 3170 of file MooseApp.C.

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

3171 {
3172  auto folder = folder_base;
3173  folder += "-restart-" + std::to_string(processor_id());
3174  return RestartableDataIO::restartableDataFolder(folder);
3175 }
MooseApp::processor_id
processor_id_type processor_id() const
Returns the MPI processor ID of the current processor.
Definition: MooseApp.h:411
RestartableDataIO::restartableDataFolder
static std::filesystem::path restartableDataFolder(const std::filesystem::path &folder_base)
Definition: RestartableDataIO.C:72

◆ restore() [1/2]

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

Restore an application from file.

Parameters
folder_baseThe backup folder base
for_restartWhether 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 1957 of file MooseApp.C.

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

1958 {
1959  TIME_SECTION("restore", 2, "Restoring Application from File");
1960 
1961  const DataNames filter_names = for_restart ? getRecoverableData() : DataNames{};
1962 
1963  _rd_reader.setInput(folder_base);
1964  _rd_reader.restore(filter_names);
1965 
1966  postRestore(for_restart);
1967 }
RestartableDataReader::setInput
void setInput(std::unique_ptr< std::stringstream > header_stream, std::unique_ptr< std::stringstream > data_stream)
Sets the input stream for reading from the stringstreams header_stream and data_stream for the header...
Definition: RestartableDataReader.C:46
MooseApp::_rd_reader
RestartableDataReader _rd_reader
Definition: MooseApp.h:1575
MooseApp::postRestore
virtual void postRestore(const bool)
Insertion point for other apps that is called after restore()
Definition: MooseApp.h:773
DataNames
std::unordered_set< std::string > DataNames
Definition: RestartableData.h:333
RestartableDataReader::restore
void restore(const DataNames &filter_names={})
Restores the restartable data.
Definition: RestartableDataReader.C:184
MooseApp::getRecoverableData
const DataNames & getRecoverableData() const
Return a reference to the recoverable data object.
Definition: MooseApp.h:721

◆ restore() [2/2]

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

Restore an application from the backup backup.

Parameters
backupThe backup
for_restartWhether 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 1970 of file MooseApp.C.

1971 {
1972  TIME_SECTION("restore", 2, "Restoring Application");
1973 
1974  const DataNames filter_names = for_restart ? getRecoverableData() : DataNames{};
1975 
1976  if (!backup)
1977  mooseError("MooseApp::restore(): Provided backup is not initialized");
1978 
1979  auto header = std::move(backup->header);
1980  mooseAssert(header, "Header not available");
1981 
1982  auto data = std::move(backup->data);
1983  mooseAssert(data, "Data not available");
1984 
1985  _rd_reader.setInput(std::move(header), std::move(data));
1986  _rd_reader.restore(filter_names);
1987 
1988  postRestore(for_restart);
1989 }
RestartableDataReader::setInput
void setInput(std::unique_ptr< std::stringstream > header_stream, std::unique_ptr< std::stringstream > data_stream)
Sets the input stream for reading from the stringstreams header_stream and data_stream for the header...
Definition: RestartableDataReader.C:46
MooseApp::_rd_reader
RestartableDataReader _rd_reader
Definition: MooseApp.h:1575
MooseApp::postRestore
virtual void postRestore(const bool)
Insertion point for other apps that is called after restore()
Definition: MooseApp.h:773
MooseApp::backup
std::unique_ptr< Backup > backup()
Backs up the application memory in a Backup.
Definition: MooseApp.C:1942
MooseApp::header
virtual std::string header() const
Returns a string to be printed at the beginning of a simulation.
Definition: MooseApp.C:2989
DataNames
std::unordered_set< std::string > DataNames
Definition: RestartableData.h:333
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
RestartableDataReader::restore
void restore(const DataNames &filter_names={})
Restores the restartable data.
Definition: RestartableDataReader.C:184
MooseApp::getRecoverableData
const DataNames & getRecoverableData() const
Return a reference to the recoverable data object.
Definition: MooseApp.h:721

◆ restoreFromInitialBackup()

void MooseApp::restoreFromInitialBackup ( const bool  for_restart)

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

Parameters
for_restartWhether 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 1992 of file MooseApp.C.

Referenced by FEProblemBase::initialSetup().

1993 {
1994  mooseAssert(hasInitialBackup(), "Missing initial backup");
1995  restore(std::move(*_initial_backup), for_restart);
1996 }
MooseApp::hasInitialBackup
bool hasInitialBackup() const
Definition: MooseApp.h:1001
MooseApp::restore
void restore(const std::filesystem::path &folder_base, const bool for_restart)
Restore an application from file.
Definition: MooseApp.C:1957
MooseApp::_initial_backup
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 ...
Definition: MooseApp.h:1611

◆ run()

void MooseApp::run ( )
virtual

Run the application.

Definition at line 2218 of file MooseApp.C.

Referenced by MooseServer::parseDocumentForDiagnostics().

2219 {
2220  TIME_SECTION("run", 3);
2221  if (getParam<bool>("show_docs"))
2222  {
2223  auto binname = appBinaryName();
2224  if (binname == "")
2225  mooseError("could not locate installed tests to run (unresolved binary/app name)");
2226  auto docspath = MooseUtils::docsDir(binname);
2227  if (docspath == "")
2228  mooseError("no installed documentation found");
2229 
2230  auto docmsgfile = MooseUtils::pathjoin(docspath, "docmsg.txt");
2231  std::string docmsg = "file://" + MooseUtils::realpath(docspath) + "/index.html";
2232  if (MooseUtils::pathExists(docmsgfile) && MooseUtils::checkFileReadable(docmsgfile))
2233  {
2234  std::ifstream ifs(docmsgfile);
2235  std::string content((std::istreambuf_iterator<char>(ifs)),
2236  (std::istreambuf_iterator<char>()));
2237  content.replace(content.find("$LOCAL_SITE_HOME"), content.length(), docmsg);
2238  docmsg = content;
2239  }
2240 
2241  Moose::out << docmsg << "\n";
2242  _early_exit_param = "--docs";
2243  _ready_to_exit = true;
2244  return;
2245  }
2246 
2247  if (showInputs() || copyInputs() || runInputs())
2248  {
2249  _early_exit_param = "--show-input, --copy-inputs, or --run";
2250  _ready_to_exit = true;
2251  return;
2252  }
2253 
2254  try
2255  {
2256  TIME_SECTION("setup", 2, "Setting Up");
2257  setupOptions();
2258  runInputFile();
2259  }
2260  catch (Parser::Error & err)
2261  {
2262  mooseAssert(_parser->getThrowOnError(), "Should be true");
2263  throw;
2264  }
2265  catch (MooseRuntimeError & err)
2266  {
2267  mooseAssert(Moose::_throw_on_error, "Should be true");
2268  throw;
2269  }
2270  catch (std::exception & err)
2271  {
2272  mooseError(err.what());
2273  }
2274 
2275  if (!_check_input)
2276  {
2277  TIME_SECTION("execute", 2, "Executing");
2278  executeExecutioner();
2279  }
2280  else
2281  {
2282  errorCheck();
2283  // Output to stderr, so it is easier for peacock to get the result
2284  Moose::err << "Syntax OK" << std::endl;
2285  }
2286 }
err
OStreamProxy err
MooseUtils::docsDir
std::string docsDir(const std::string &app_name)
Definition: MooseUtils.C:125
MooseApp::setupOptions
virtual void setupOptions()
Setup options based on InputParameters.
Definition: MooseApp.C:1272
MooseApp::_parser
const std::shared_ptr< Parser > _parser
Parser for parsing the input file (owns the root hit node)
Definition: MooseApp.h:1230
MooseApp::appBinaryName
virtual std::string appBinaryName() const
Definition: MooseApp.h:144
MooseApp::runInputs
bool runInputs()
Handles the run input parameter logic: Checks to see whether a directory exists in user space and lau...
Definition: MooseApp.C:2392
MooseApp::_check_input
bool _check_input
true if we want to just check the input file
Definition: MooseApp.h:1347
MooseUtils::realpath
std::string realpath(const std::string &path)
Definition: MooseUtils.C:1136
MooseApp::showInputs
bool showInputs() const
Prints a message showing the installable inputs for a given application (if getInstallableInputs has ...
Definition: MooseApp.C:2289
MooseUtils::pathjoin
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:59
MooseApp::executeExecutioner
virtual void executeExecutioner()
Execute the Executioner that was built.
Definition: MooseApp.C:1852
MooseApp::runInputFile
virtual void runInputFile()
Actually build everything in the input file.
Definition: MooseApp.C:1772
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseUtils::pathExists
bool pathExists(const std::string &path)
Definition: MooseUtils.C:247
MooseRuntimeError
Exception to be thrown whenever we have _throw_on_error set and a mooseError() is emitted...
Definition: MooseError.h:133
MooseUtils::checkFileReadable
bool checkFileReadable(const std::string &filename, bool check_line_endings, bool throw_on_unreadable, bool check_for_git_lfs_pointer)
Definition: MooseUtils.C:254
MooseApp::_ready_to_exit
bool _ready_to_exit
Definition: MooseApp.h:1304
MooseApp::copyInputs
bool copyInputs()
Handles the copy_inputs input parameter logic: Checks to see whether the passed argument is valid (a ...
Definition: MooseApp.C:2327
Moose::_throw_on_error
bool _throw_on_error
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or wh...
Definition: Moose.C:797
MooseApp::errorCheck
void errorCheck()
Runs post-initialization error checking that cannot be run correctly unless the simulation has been f...
Definition: MooseApp.C:1816
MooseApp::_early_exit_param
std::string _early_exit_param
Indicates if simulation is ready to exit, and keeps track of which param caused it to exit...
Definition: MooseApp.h:1303

◆ runInputFile()

void MooseApp::runInputFile ( )
virtual

Actually build everything in the input file.

Definition at line 1772 of file MooseApp.C.

Referenced by run().

1773 {
1774  TIME_SECTION("runInputFile", 3);
1775 
1776  // If early exit param has been set, then just return
1777  if (_ready_to_exit)
1778  return;
1779 
1780  _action_warehouse.executeAllActions();
1781 
1782  if (isParamSetByUser("csg_only"))
1783  {
1784  _early_exit_param = "--csg-only";
1785  _ready_to_exit = true;
1786  }
1787  else if (isParamSetByUser("mesh_only"))
1788  {
1789  _early_exit_param = "--mesh-only";
1790  _ready_to_exit = true;
1791  }
1792  else if (isParamSetByUser("split_mesh"))
1793  {
1794  _early_exit_param = "--split-mesh";
1795  _ready_to_exit = true;
1796  }
1797  else if (isParamSetByUser("parse_neml2_only"))
1798  {
1799  _early_exit_param = "--parse-neml2-only";
1800  _ready_to_exit = true;
1801  }
1802  else if (getParam<bool>("list_constructed_objects"))
1803  {
1804  // TODO: ask multiapps for their constructed objects
1805  _early_exit_param = "--list-constructed-objects";
1806  _ready_to_exit = true;
1807  std::stringstream ss;
1808  for (const auto & obj : _factory.getConstructedObjects())
1809  ss << obj << '\n';
1810  outputMachineReadableData(
1811  "list_constructed_objects", "**START OBJECT DATA**\n", "\n**END OBJECT DATA**", ss.str());
1812  }
1813 }
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
MooseApp::outputMachineReadableData
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...
Definition: MooseApp.C:3651
MooseApp::_factory
Factory _factory
Definition: MooseApp.h:1298
ActionWarehouse::executeAllActions
void executeAllActions()
This method loops over all actions in the warehouse and executes them.
Definition: ActionWarehouse.C:337
MooseApp::_ready_to_exit
bool _ready_to_exit
Definition: MooseApp.h:1304
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205
MooseApp::_early_exit_param
std::string _early_exit_param
Indicates if simulation is ready to exit, and keeps track of which param caused it to exit...
Definition: MooseApp.h:1303

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

Referenced by run().

2393 {
2394  if (isParamSetByUser("run"))
2395  {
2396  if (comm().size() > 1)
2397  mooseError("The --run option should not be ran in parallel");
2398 
2399  // Pass everything after --run on the cli to the TestHarness
2400  const auto find_run_it = std::as_const(*_command_line).findCommandLineParam("run");
2401  const auto & cl_entries = std::as_const(*_command_line).getEntries();
2402  mooseAssert(find_run_it != cl_entries.end(), "Didn't find the option");
2403  std::string test_args;
2404  for (auto it = std::next(find_run_it); it != cl_entries.end(); ++it)
2405  for (const auto & arg : it->raw_args)
2406  {
2407  test_args += " " + arg;
2408  libMesh::add_command_line_name(arg);
2409  }
2410 
2411  auto working_dir = MooseUtils::getCurrentWorkingDir();
2412  if (MooseUtils::findTestRoot() == "")
2413  {
2414  auto bin_name = appBinaryName();
2415  if (bin_name == "")
2416  mooseError("Could not locate binary name relative to installed location");
2417 
2418  auto cmd_name = Moose::getExecutableName();
2419  mooseError(
2420  "Could not locate installed tests from the current working directory:",
2421  working_dir,
2422  ".\nMake sure you are executing this command from within a writable installed inputs ",
2423  "directory.\nRun \"",
2424  cmd_name,
2425  " --copy-inputs <dir>\" to copy the contents of <dir> to a \"./",
2426  bin_name,
2427  "_<dir>\" directory.\nChange into that directory and try \"",
2428  cmd_name,
2429  " --run <dir>\" again.");
2430  }
2431 
2432  // Set this application as the app name for the moose_test_runner script that we're running
2433  setenv("MOOSE_TEST_RUNNER_APP_NAME", appBinaryName().c_str(), true);
2434 
2435  const std::string cmd = MooseUtils::runTestsExecutable() + test_args;
2436  Moose::out << "Working Directory: " << working_dir << "\nRunning Command: " << cmd << std::endl;
2437  mooseAssert(comm().size() == 1, "Should be run in serial");
2438  const auto return_value = system(cmd.c_str());
2439  if (!WIFEXITED(return_value))
2440  mooseError("Process exited unexpectedly");
2441  setExitCode(WEXITSTATUS(return_value));
2442  return true;
2443  }
2444 
2445  return false;
2446 }
MooseApp::appBinaryName
virtual std::string appBinaryName() const
Definition: MooseApp.h:144
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
MooseUtils::runTestsExecutable
std::string runTestsExecutable()
Definition: MooseUtils.C:65
libMesh::add_command_line_name
void add_command_line_name(const std::string &name)
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseUtils::getCurrentWorkingDir
std::string getCurrentWorkingDir()
Definition: MooseUtils.C:436
MooseApp::setExitCode
void setExitCode(const int exit_code)
Sets the exit code that the application will exit with.
Definition: MooseApp.h:162
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205
Moose::getExecutableName
std::string getExecutableName()
Gets the name of the running executable on Mac OS X and linux.
Definition: ExecutablePath.C:60
MooseUtils::findTestRoot
std::string findTestRoot()
Definition: MooseUtils.C:75

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

Referenced by setupOptions().

2032 {
2033  _enable_unused_check = warn_is_error ? ERROR_UNUSED : WARN_UNUSED;
2034 }
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check

◆ setErrorOverridden()

void MooseApp::setErrorOverridden ( )

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

Definition at line 2212 of file MooseApp.C.

Referenced by setupOptions().

2213 {
2214  _error_overridden = true;
2215 }
MooseApp::_error_overridden
bool _error_overridden
Indicates whether warnings or errors are displayed when overridden parameters are detected...
Definition: MooseApp.h:1301

◆ setExecutioner()

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

Set the Executioner for this App.

Definition at line 343 of file MooseApp.h.

Referenced by CreateExecutionerAction::act().

343 { _executioner = executioner; }
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260

◆ setExecutor()

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

Definition at line 344 of file MooseApp.h.

344 { _executor = executor; }
MooseApp::_executor
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1263

◆ setExitCode()

void MooseApp::setExitCode ( const int  exit_code)
inline

Sets the exit code that the application will exit with.

Definition at line 162 of file MooseApp.h.

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

162 { _exit_code = exit_code; }
MooseApp::_exit_code
int _exit_code
The exit code.
Definition: MooseApp.h:1306

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

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

424 { _initial_from_file = flag; }
MooseApp::_initial_from_file
bool _initial_from_file
This variable indicates when a request has been made to restart from an Exodus file.
Definition: MooseApp.h:1309

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

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

436  {
437  _ex_reader = exreader;
438  }
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:1312

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

306 { _global_time_offset = offset; }
MooseApp::_global_time_offset
Real _global_time_offset
Offset of the local App time to the "global" problem time.
Definition: MooseApp.h:1211

◆ setMFEMDevice()

void MooseApp::setMFEMDevice ( const std::string &  device_string,
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 3695 of file MooseApp.C.

Referenced by MFEMProblemSolve::MFEMProblemSolve().

3696 {
3697  const auto string_vec = MooseUtils::split(device_string, ",");
3698  auto string_set = std::set<std::string>(string_vec.begin(), string_vec.end());
3699  if (!_mfem_device)
3700  {
3701  _mfem_device = std::make_shared<mfem::Device>(device_string);
3702  _mfem_devices = std::move(string_set);
3703  _mfem_device->Print(Moose::out);
3704  }
3705  else if (!device_string.empty() && string_set != _mfem_devices)
3706  mooseError("Attempted to configure with MFEM devices '",
3707  MooseUtils::join(string_set, " "),
3708  "', but we have already configured the MFEM device object with the devices '",
3709  MooseUtils::join(_mfem_devices, " "),
3710  "'");
3711 }
MooseApp::_mfem_devices
std::set< std::string > _mfem_devices
MFEM supported devices based on user-provided config.
Definition: MooseApp.h:1623
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseUtils::split
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count)
Definition: MooseUtils.C:1031
MooseApp::_mfem_device
std::shared_ptr< mfem::Device > _mfem_device
The MFEM Device object.
Definition: MooseApp.h:1620

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

1757 {
1758  _output_file_base = output_file_base;
1759 
1760  // Reset the file base in the outputs
1761  _output_warehouse.resetFileBase();
1762 
1763  // Reset the file base in multiapps (if they have been constructed yet)
1764  if (getExecutioner())
1765  for (auto & multi_app : feProblem().getMultiAppWarehouse().getObjects())
1766  multi_app->setAppOutputFileBase();
1767 
1768  _file_base_set_by_user = true;
1769 }
MooseApp::_file_base_set_by_user
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
Definition: MooseApp.h:1196
MooseApp::feProblem
FEProblemBase & feProblem() const
Definition: MooseApp.C:2043
OutputWarehouse::resetFileBase
void resetFileBase()
Resets the file base for all FileOutput objects.
Definition: OutputWarehouse.C:410
MooseApp::getExecutioner
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
Definition: MooseApp.C:2206
MooseApp::_output_warehouse
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:1227
MooseApp::_output_file_base
std::string _output_file_base
The output file basename.
Definition: MooseApp.h:1193

◆ 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
numbersMap of outputter names and file numbers
See also
MultiApp TransientMultiApp OutputWarehouse

Definition at line 534 of file MooseApp.h.

535  {
536  _output_file_numbers = numbers;
537  }
MooseApp::_output_file_numbers
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 mu...
Definition: MooseApp.h:1344

◆ setOutputPosition()

void MooseApp::setOutputPosition ( const Point &  p)

Tell the app to output in a specific position.

Definition at line 2462 of file MooseApp.C.

2463 {
2464  _output_position_set = true;
2465  _output_position = p;
2466  _output_warehouse.meshChanged();
2467 
2468  if (_executioner.get())
2469  _executioner->parentOutputPositionChanged();
2470 }
MooseApp::_output_position_set
bool _output_position_set
Whether or not an output position has been set for this app.
Definition: MooseApp.h:1199
OutputWarehouse::meshChanged
void meshChanged()
Calls the meshChanged method for every output object.
Definition: OutputWarehouse.C:190
MooseApp::_executioner
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1260
MooseApp::_output_position
Point _output_position
The output position.
Definition: MooseApp.h:1202
MooseApp::_output_warehouse
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:1227

◆ setRecover()

void MooseApp::setRecover ( bool  value)

Definition at line 3001 of file MooseApp.C.

3002 {
3003  _recover = value;
3004 }
value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
MooseApp::_recover
bool _recover
Whether or not this is a recovery run.
Definition: MooseApp.h:1318

◆ setRestart()

void MooseApp::setRestart ( bool  value)

Sets the restart/recover flags.

Parameters
stateThe state to set the flag to

Definition at line 2995 of file MooseApp.C.

Referenced by FEProblemBase::setRestartFile().

2996 {
2997  _restart = value;
2998 }
MooseApp::_restart
bool _restart
Whether or not this is a restart run.
Definition: MooseApp.h:1321
value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ setRestartRecoverFileBase()

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

mutator for recover_base (set by RecoverBaseAction)

Definition at line 506 of file MooseApp.h.

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

507  {
508  if (file_base.empty())
509  _restart_recover_base = MooseUtils::getLatestCheckpointFilePrefix(getCheckpointFiles());
510  else
511  _restart_recover_base = file_base;
512  }
MooseApp::getCheckpointFiles
std::list< std::string > getCheckpointFiles() const
Extract all possible checkpoint file names.
Definition: MooseApp.C:2505
MooseApp::_restart_recover_base
std::string _restart_recover_base
The base name to restart/recover from. If blank then we will find the newest checkpoint file...
Definition: MooseApp.h:1336
MooseUtils::getLatestCheckpointFilePrefix
std::string getLatestCheckpointFilePrefix(const std::list< std::string > &checkpoint_files)
Definition: MooseUtils.C:819

◆ setStartTime()

void MooseApp::setStartTime ( Real  time)

Set the starting time for the simulation.

This will override any choice made in the input file.

Parameters
timeThe start time for the simulation.

Definition at line 2512 of file MooseApp.C.

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

2513 {
2514  _start_time_set = true;
2515  _start_time = time;
2516 }
MooseApp::_start_time
Real _start_time
The time at which to start the simulation.
Definition: MooseApp.h:1208
MooseApp::_start_time_set
bool _start_time_set
Whether or not an start time has been set.
Definition: MooseApp.h:1205

◆ setupOptions()

void MooseApp::setupOptions ( )
virtual

Setup options based on InputParameters.

Definition at line 1272 of file MooseApp.C.

Referenced by run().

1273 {
1274  TIME_SECTION("setupOptions", 5, "Setting Up Options");
1275 
1276  // Print the header, this is as early as possible
1277  if (header().length() && !getParam<bool>("suppress_header"))
1278  _console << header() << std::endl;
1279 
1280  if (getParam<bool>("error_unused"))
1281  setCheckUnusedFlag(true);
1282  else if (getParam<bool>("allow_unused"))
1283  setCheckUnusedFlag(false);
1284 
1285  if (getParam<bool>("error_override"))
1286  setErrorOverridden();
1287 
1288  _distributed_mesh_on_command_line = getParam<bool>("distributed_mesh");
1289 
1290  if (getParam<bool>("trap_fpe"))
1291  {
1292  _trap_fpe = true;
1293  _perf_graph.setActive(false);
1294  if (getParam<bool>("no_trap_fpe"))
1295  mooseError("Cannot use both \"--trap-fpe\" and \"--no-trap-fpe\" flags.");
1296  }
1297  else if (getParam<bool>("no_trap_fpe"))
1298  _trap_fpe = false;
1299 
1300  // Turn all warnings in MOOSE to errors (almost see next logic block)
1301  Moose::_warnings_are_errors = getParam<bool>("error");
1302 
1303  // Deprecated messages can be toggled to errors independently from everything else.
1304  Moose::_deprecated_is_error = getParam<bool>("error_deprecated");
1305 
1306  if (isUltimateMaster()) // makes sure coloring isn't reset incorrectly in multi-app settings
1307  {
1308  // Set from command line
1309  auto color = getParam<MooseEnum>("color");
1310  if (!isParamSetByUser("color"))
1311  {
1312  // Set from deprecated --no-color
1313  if (getParam<bool>("no_color"))
1314  color = "off";
1315  // Set from environment
1316  else
1317  {
1318  char * c_color = std::getenv("MOOSE_COLOR");
1319  if (c_color)
1320  color.assign(std::string(c_color), "While assigning environment variable MOOSE_COLOR");
1321  }
1322  }
1323 
1324  if (color == "auto")
1325  Moose::setColorConsole(true);
1326  else if (color == "on")
1327  Moose::setColorConsole(true, true);
1328  else if (color == "off")
1329  Moose::setColorConsole(false);
1330  else
1331  mooseAssert(false, "Should not hit");
1332 
1333  // After setting color so that non-yellow deprecated is honored
1334  if (getParam<bool>("no_color"))
1335  mooseDeprecated("The --no-color flag is deprecated. Use '--color off' instead.");
1336  }
1337 
1338 // If there's no threading model active, but the user asked for
1339 // --n-threads > 1 on the command line, throw a mooseError. This is
1340 // intended to prevent situations where the user has potentially
1341 // built MOOSE incorrectly (neither TBB nor pthreads found) and is
1342 // asking for multiple threads, not knowing that there will never be
1343 // any threads launched.
1344 #if !LIBMESH_USING_THREADS
1345  if (libMesh::command_line_value("--n-threads", 1) > 1)
1346  mooseError("You specified --n-threads > 1, but there is no threading model active!");
1347 #endif
1348 
1349  // Build a minimal running application, ignoring the input file.
1350  if (getParam<bool>("minimal"))
1351  createMinimalApp();
1352 
1353  else if (getParam<bool>("display_version"))
1354  {
1355  Moose::out << getPrintableVersion() << std::endl;
1356  _early_exit_param = "--version";
1357  _ready_to_exit = true;
1358  return;
1359  }
1360  else if (getParam<bool>("help"))
1361  {
1362  _command_line->printUsage();
1363  _early_exit_param = "--help";
1364  _ready_to_exit = true;
1365  }
1366  else if (getParam<bool>("dump") || isParamSetByUser("dump_search"))
1367  {
1368  const std::string search =
1369  isParamSetByUser("dump_search") ? getParam<std::string>("dump_search") : "";
1370 
1371  JsonSyntaxTree tree(search);
1372 
1373  {
1374  TIME_SECTION("dump", 1, "Building Syntax Tree");
1375  _builder.buildJsonSyntaxTree(tree);
1376  }
1377 
1378  // Check if second arg is valid or not
1379  if ((tree.getRoot()).is_object())
1380  {
1381  // Turn off live printing so that it doesn't mess with the dump
1382  _perf_graph.disableLivePrint();
1383 
1384  JsonInputFileFormatter formatter;
1385  Moose::out << "\n### START DUMP DATA ###\n"
1386  << formatter.toString(tree.getRoot()) << "\n### END DUMP DATA ###" << std::endl;
1387  _early_exit_param = "--dump";
1388  _ready_to_exit = true;
1389  }
1390  else
1391  mooseError("Search parameter '", search, "' was not found in the registered syntax.");
1392  }
1393  else if (getParam<bool>("registry"))
1394  {
1395  _perf_graph.disableLivePrint();
1396 
1397  Moose::out << "Label\tType\tName\tClass\tFile\n";
1398 
1399  auto & objmap = Registry::allObjects();
1400  for (auto & entry : objmap)
1401  for (auto & obj : entry.second)
1402  Moose::out << entry.first << "\tobject\t" << obj->name() << "\t" << obj->_classname << "\t"
1403  << obj->_file << "\n";
1404 
1405  auto & actmap = Registry::allActions();
1406  for (auto & entry : actmap)
1407  {
1408  for (auto & act : entry.second)
1409  Moose::out << entry.first << "\taction\t" << act->_name << "\t" << act->_classname << "\t"
1410  << act->_file << "\n";
1411  }
1412  _early_exit_param = "--registry";
1413  _ready_to_exit = true;
1414  }
1415  else if (getParam<bool>("registry_hit"))
1416  {
1417  _perf_graph.disableLivePrint();
1418 
1419  Moose::out << "### START REGISTRY DATA ###\n";
1420 
1421  hit::Section root("");
1422  auto sec = new hit::Section("registry");
1423  root.addChild(sec);
1424  auto objsec = new hit::Section("objects");
1425  sec->addChild(objsec);
1426 
1427  auto & objmap = Registry::allObjects();
1428  for (auto & entry : objmap)
1429  for (auto & obj : entry.second)
1430  {
1431  auto ent = new hit::Section("entry");
1432  objsec->addChild(ent);
1433  ent->addChild(new hit::Field("label", hit::Field::Kind::String, entry.first));
1434  ent->addChild(new hit::Field("type", hit::Field::Kind::String, "object"));
1435  ent->addChild(new hit::Field("name", hit::Field::Kind::String, obj->name()));
1436  ent->addChild(new hit::Field("class", hit::Field::Kind::String, obj->_classname));
1437  ent->addChild(new hit::Field("file", hit::Field::Kind::String, obj->_file));
1438  }
1439 
1440  auto actsec = new hit::Section("actions");
1441  sec->addChild(actsec);
1442  auto & actmap = Registry::allActions();
1443  for (auto & entry : actmap)
1444  for (auto & act : entry.second)
1445  {
1446  auto ent = new hit::Section("entry");
1447  actsec->addChild(ent);
1448  ent->addChild(new hit::Field("label", hit::Field::Kind::String, entry.first));
1449  ent->addChild(new hit::Field("type", hit::Field::Kind::String, "action"));
1450  ent->addChild(new hit::Field("task", hit::Field::Kind::String, act->_name));
1451  ent->addChild(new hit::Field("class", hit::Field::Kind::String, act->_classname));
1452  ent->addChild(new hit::Field("file", hit::Field::Kind::String, act->_file));
1453  }
1454 
1455  Moose::out << root.render();
1456 
1457  Moose::out << "\n### END REGISTRY DATA ###\n";
1458  _early_exit_param = "--registry_hit";
1459  _ready_to_exit = true;
1460  }
1461  else if (getParam<bool>("definition"))
1462  {
1463  _perf_graph.disableLivePrint();
1464 
1465  JsonSyntaxTree tree("");
1466  _builder.buildJsonSyntaxTree(tree);
1467  SONDefinitionFormatter formatter;
1468  Moose::out << "%-START-SON-DEFINITION-%\n"
1469  << formatter.toString(tree.getRoot()) << "\n%-END-SON-DEFINITION-%\n";
1470  _early_exit_param = "--definition";
1471  _ready_to_exit = true;
1472  }
1473  else if (getParam<bool>("yaml") || isParamSetByUser("yaml_search"))
1474  {
1475  const std::string search =
1476  isParamSetByUser("yaml_search") ? getParam<std::string>("yaml_search") : "";
1477  _perf_graph.disableLivePrint();
1478 
1479  _builder.initSyntaxFormatter(Moose::Builder::YAML, true);
1480  _builder.buildFullTree(search);
1481 
1482  _early_exit_param = "--yaml";
1483  _ready_to_exit = true;
1484  }
1485  else if (getParam<bool>("json") || isParamSetByUser("json_search"))
1486  {
1487  const std::string search =
1488  isParamSetByUser("json_search") ? getParam<std::string>("json_search") : "";
1489  _perf_graph.disableLivePrint();
1490 
1491  JsonSyntaxTree tree(search);
1492  _builder.buildJsonSyntaxTree(tree);
1493 
1494  outputMachineReadableData(
1495  "json", "**START JSON DATA**\n", "\n**END JSON DATA**", tree.getRoot().dump(2));
1496  _early_exit_param = "--json";
1497  _ready_to_exit = true;
1498  }
1499  else if (getParam<bool>("syntax"))
1500  {
1501  _perf_graph.disableLivePrint();
1502 
1503  std::multimap<std::string, Syntax::ActionInfo> syntax = _syntax.getAssociatedActions();
1504  std::stringstream ss;
1505  for (const auto & it : syntax)
1506  ss << it.first << "\n";
1507  outputMachineReadableData("syntax", "**START SYNTAX DATA**\n", "**END SYNTAX DATA**", ss.str());
1508  _early_exit_param = "--syntax";
1509  _ready_to_exit = true;
1510  }
1511  else if (getParam<bool>("show_type"))
1512  {
1513  _perf_graph.disableLivePrint();
1514 
1515  Moose::out << "MooseApp Type: " << type() << std::endl;
1516  _early_exit_param = "--show-type";
1517  _ready_to_exit = true;
1518  }
1519  else if (getParam<bool>("show_capabilities"))
1520  {
1521  _perf_graph.disableLivePrint();
1522  outputMachineReadableData("show_capabilities",
1523  "**START JSON DATA**\n",
1524  "\n**END JSON DATA**",
1525  Moose::Capabilities::getCapabilityRegistry().dump());
1526  _ready_to_exit = true;
1527  }
1528  else if (isParamValid("check_capabilities"))
1529  {
1530  _perf_graph.disableLivePrint();
1531  const auto & capabilities = getParam<std::string>("check_capabilities");
1532  auto [status, reason, doc] = Moose::Capabilities::getCapabilityRegistry().check(capabilities);
1533  const bool pass = status == CapabilityUtils::CERTAIN_PASS;
1534  _console << "Capabilities '" << capabilities << "' are " << (pass ? "" : "not ") << "fulfilled."
1535  << std::endl;
1536  _ready_to_exit = true;
1537  if (!pass)
1538  _exit_code = 77;
1539  return;
1540  }
1541  else if (!getInputFileNames().empty())
1542  {
1543  if (isParamSetByUser("recover"))
1544  {
1545  // We need to set the flag manually here since the recover parameter is a string type (takes
1546  // an optional filename)
1547  _recover = true;
1548  const auto & recover = getParam<std::string>("recover");
1549  if (recover.size())
1550  _restart_recover_base = recover;
1551  }
1552 
1553  _builder.build();
1554 
1555  if (isParamValid("required_capabilities"))
1556  {
1557  _perf_graph.disableLivePrint();
1558 
1559  const auto required_capabilities = getParam<std::string>("required_capabilities");
1560  auto [status, reason, doc] =
1561  Moose::Capabilities::getCapabilityRegistry().check(required_capabilities);
1562  if (status < CapabilityUtils::UNKNOWN)
1563  {
1564  mooseInfo("Required capabilities '", required_capabilities, "' not fulfilled.");
1565  _ready_to_exit = true;
1566  // we use code 77 as "skip" in the Testharness
1567  _exit_code = 77;
1568  return;
1569  }
1570  if (status == CapabilityUtils::UNKNOWN)
1571  mooseError("Required capabilities '",
1572  required_capabilities,
1573  "' are not specific enough. A comparison test is performed on an undefined "
1574  "capability. Disambiguate this requirement by adding an existence/non-existence "
1575  "requirement. Example: 'unknown<1.2.3' should become 'unknown & unknown<1.2.3' "
1576  "or '!unknown | unknown<1.2.3'");
1577  }
1578 
1579  // Lambda to check for mutually exclusive parameters
1580  auto isExclusiveParamSetByUser =
1581  [this](const std::vector<std::string> & group, const std::string & param)
1582  {
1583  auto is_set = isParamSetByUser(param);
1584  if (is_set)
1585  for (const auto & p : group)
1586  if (p != param && isParamSetByUser(p))
1587  mooseError("Parameters '" + p + "' and '" + param +
1588  "' are mutually exclusive. Please choose only one of them.");
1589  return is_set;
1590  };
1591 
1592  // The following parameters set the final task and so are mutually exclusive.
1593  const std::vector<std::string> final_task_params = {
1594  "csg_only", "mesh_only", "split_mesh", "parse_neml2_only"};
1595  if (isExclusiveParamSetByUser(final_task_params, "csg_only"))
1596  {
1597  // Error checking on incompatible command line options
1598  if (_distributed_mesh_on_command_line)
1599  mooseError("--csg-only cannot be used in conjunction with --distributed-mesh");
1600  const bool has_mesh_split = isParamSetByUser("split_file") || _use_split;
1601  if (has_mesh_split)
1602  mooseError("--csg-only is not compatible with any mesh splitting options");
1603  if (isParamSetByUser("refinements"))
1604  mooseError("--csg-only cannot be used in conjunction with -r refinements option");
1605  if (!isUltimateMaster())
1606  mooseError("--csg-only option cannot be used as a Subapp");
1607  if (_recover)
1608  mooseError("--csg-only option cannot be used in recovery mode");
1609 
1610  _syntax.registerTaskName("execute_csg_generators", true);
1611  _syntax.addDependency("execute_csg_generators", "execute_mesh_generators");
1612  _syntax.addDependency("recover_meta_data", "execute_csg_generators");
1613 
1614  _syntax.registerTaskName("csg_only", true);
1615  _syntax.addDependency("csg_only", "recover_meta_data");
1616  _syntax.addDependency("set_mesh_base", "csg_only");
1617  _action_warehouse.setFinalTask("csg_only");
1618  }
1619  else if (isExclusiveParamSetByUser(final_task_params, "mesh_only"))
1620  {
1621  // If we are looking to just check the input, there is no need to
1622  // call MeshOnlyAction and generate a mesh
1623  if (_check_input)
1624  _action_warehouse.setFinalTask("setup_mesh_complete");
1625  else
1626  {
1627  _syntax.registerTaskName("mesh_only", true);
1628  _syntax.addDependency("mesh_only", "setup_mesh_complete");
1629  _syntax.addDependency("determine_system_type", "mesh_only");
1630  _action_warehouse.setFinalTask("mesh_only");
1631  }
1632  }
1633  else if (isExclusiveParamSetByUser(final_task_params, "split_mesh"))
1634  {
1635  _split_mesh = true;
1636  _syntax.registerTaskName("split_mesh", true);
1637  _syntax.addDependency("split_mesh", "setup_mesh_complete");
1638  _syntax.addDependency("determine_system_type", "split_mesh");
1639  _action_warehouse.setFinalTask("split_mesh");
1640  }
1641  else if (isExclusiveParamSetByUser(final_task_params, "parse_neml2_only"))
1642  {
1643  _syntax.registerTaskName("parse_neml2");
1644  _syntax.addDependency("determine_system_type", "parse_neml2");
1645  _action_warehouse.setFinalTask("parse_neml2");
1646  }
1647  _action_warehouse.build();
1648 
1649  // Setup the AppFileBase for use by the Outputs or other systems that need output file info
1650  {
1651  // Extract the CommonOutputAction
1652  const auto common_actions = _action_warehouse.getActions<CommonOutputAction>();
1653  mooseAssert(common_actions.size() <= 1, "Should not be more than one CommonOutputAction");
1654  const Action * common = common_actions.empty() ? nullptr : *common_actions.begin();
1655 
1656  // If file_base is set in CommonOutputAction through parsing input, obtain the file_base
1657  if (common && common->isParamValid("file_base"))
1658  {
1659  _output_file_base = common->getParam<std::string>("file_base");
1660  _file_base_set_by_user = true;
1661  }
1662  else if (isUltimateMaster())
1663  {
1664  // if this app is a master, we use the first input file name as the default file base.
1665  // use proximate here because the input file is an absolute path
1666  const auto & base = getLastInputFileName();
1667  size_t pos = base.find_last_of('.');
1668  _output_file_base = base.substr(0, pos);
1669  // Note: we did not append "_out" in the file base here because we do not want to
1670  // have it in between the input file name and the object name for Output/*
1671  // syntax.
1672  }
1673  // default file base for multiapps is set by MultiApp
1674  }
1675  }
1676  // No input file provided but we have other arguments (so don't just show print usage)
1677  else if (!isParamSetByUser("input_file") && _command_line->getArguments().size() > 2)
1678  {
1679  mooseAssert(getInputFileNames().empty(), "Should be empty");
1680 
1681  if (_check_input)
1682  mooseError("You specified --check-input, but did not provide an input file. Add -i "
1683  "<inputfile> to your command line.");
1684 
1685  mooseError("No input files specified. Add -i <inputfile> to your command line.");
1686  }
1687  else if (isParamValid("language_server") && getParam<bool>("language_server"))
1688  {
1689  _perf_graph.disableLivePrint();
1690 
1691  // Reset output to the buffer what was cached before it was turned it off
1692  if (!Moose::out.rdbuf() && _output_buffer_cache)
1693  Moose::out.rdbuf(_output_buffer_cache);
1694 
1695  // Start a language server that communicates using an iostream connection
1696  MooseServer moose_server(*this);
1697 
1698  moose_server.run();
1699 
1700  _early_exit_param = "--language-server";
1701  _ready_to_exit = true;
1702  }
1703 
1704  else /* The catch-all case for bad options or missing options, etc. */
1705  {
1706  _command_line->printUsage();
1707  _early_exit_param = "bad or missing";
1708  _ready_to_exit = true;
1709  _exit_code = 1;
1710  }
1711 
1712 #ifdef MOOSE_KOKKOS_ENABLED
1713  for (auto & action : _action_warehouse.allActionBlocks())
1714  {
1715  auto object_action = std::dynamic_pointer_cast<MooseObjectAction>(action);
1716  if (object_action &&
1717  object_action->getObjectParams().isParamValid(MooseBase::kokkos_object_param))
1718  {
1719  if (!isKokkosAvailable())
1720  mooseError("Attempted to add a ",
1721  object_action->getMooseObjectType(),
1722  " but no GPU was detected in the system.");
1723 
1724  _has_kokkos_objects = true;
1725  }
1726  }
1727 #endif
1728 
1729  Moose::out << std::flush;
1730 }
MooseBase::mooseInfo
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:321
Moose::Builder::build
void build()
Parse an input file (or text string if provided) consisting of hit syntax and setup objects in the MO...
Definition: Builder.C:300
MooseApp::_perf_graph
PerfGraph & _perf_graph
The PerfGraph object for this application (recoverable)
Definition: MooseApp.h:1251
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
MooseApp::_restart_recover_base
std::string _restart_recover_base
The base name to restart/recover from. If blank then we will find the newest checkpoint file...
Definition: MooseApp.h:1336
Syntax::getAssociatedActions
const std::multimap< std::string, ActionInfo > & getAssociatedActions() const
Return all Syntax to Action associations.
Definition: Syntax.C:374
Moose::Builder::buildFullTree
void buildFullTree(const std::string &search_string)
Use MOOSE Factories to construct a full parse tree for documentation or echoing input.
Definition: Builder.C:579
MooseApp::_file_base_set_by_user
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
Definition: MooseApp.h:1196
Syntax::addDependency
void addDependency(const std::string &task, const std::string &pre_req)
Definition: Syntax.C:60
MooseApp::setCheckUnusedFlag
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 ...
Definition: MooseApp.C:2031
Moose::_warnings_are_errors
bool _warnings_are_errors
Variable to toggle any warning into an error (includes deprecated code warnings)
Definition: Moose.C:795
Syntax::registerTaskName
void registerTaskName(const std::string &task, bool should_auto_build=false)
Method to register a new task.
Definition: Syntax.C:20
Registry::allActions
static const std::map< std::string, std::vector< std::shared_ptr< RegistryEntryBase > > > & allActions()
Returns a per-label keyed map of all Actions in the registry.
Definition: Registry.h:229
ActionWarehouse::setFinalTask
void setFinalTask(const std::string &task)
Definition: ActionWarehouse.C:45
MooseApp::_use_split
const bool _use_split
Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)
Definition: MooseApp.h:1327
MooseApp::_check_input
bool _check_input
true if we want to just check the input file
Definition: MooseApp.h:1347
dynamic_pointer_cast
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Definition: CastUniquePointer.h:21
MooseApp::_syntax
Syntax _syntax
Syntax of the input file.
Definition: MooseApp.h:1214
MooseApp::syntax
Syntax & syntax()
Returns a writable reference to the syntax object.
Definition: MooseApp.h:225
MooseApp::_trap_fpe
bool _trap_fpe
Whether or not FPE trapping should be turned on.
Definition: MooseApp.h:1333
Registry::allObjects
static const std::map< std::string, std::vector< std::shared_ptr< RegistryEntryBase > > > & allObjects()
Returns a per-label keyed map of all MooseObjects in the registry.
Definition: Registry.h:224
MooseApp::_action_warehouse
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1224
SONDefinitionFormatter
This class produces a dump of the InputFileParameters in the Standard Object Notation (SON) format fo...
Definition: SONDefinitionFormatter.h:22
JsonSyntaxTree
Holds the syntax in a Json::Value tree.
Definition: JsonSyntaxTree.h:22
Action
Base class for actions.
Definition: Action.h:34
MooseApp::_exit_code
int _exit_code
The exit code.
Definition: MooseApp.h:1306
Moose::Capabilities::check
CapabilityUtils::Result check(const std::string &requested_capabilities) const
check if the given required capabilities are fulfilled, returns a bool, a reason, and a verbose docum...
Definition: Capabilities.C:82
status
MPI_Status status
MooseApp::getLastInputFileName
const std::string & getLastInputFileName() const
Definition: MooseApp.C:1740
MooseApp::setErrorOverridden
void setErrorOverridden()
Set a flag so that the parser will throw an error if overridden parameters are detected.
Definition: MooseApp.C:2212
libMesh::command_line_value
T command_line_value(const std::string &, T)
MooseBase::kokkos_object_param
static const std::string kokkos_object_param
The name of the parameter that indicates an object is a Kokkos functor.
Definition: MooseBase.h:64
Moose::_deprecated_is_error
bool _deprecated_is_error
Variable to toggle only deprecated warnings as errors.
Definition: Moose.C:796
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
PerfGraph::setActive
void setActive(bool active)
Turn on or off timing.
Definition: PerfGraph.h:129
Moose::Builder::initSyntaxFormatter
void initSyntaxFormatter(SyntaxFormatterType type, bool dump_mode)
Creates a syntax formatter for printing.
Definition: Builder.C:402
PerfGraph::disableLivePrint
void disableLivePrint()
Completely disables Live Print (cannot be restarted)
Definition: PerfGraph.C:67
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseApp::isKokkosAvailable
bool isKokkosAvailable() const
Get whether Kokkos is available.
Definition: MooseApp.h:1101
MooseApp::_recover
bool _recover
Whether or not this is a recovery run.
Definition: MooseApp.h:1318
Moose::Builder::buildJsonSyntaxTree
void buildJsonSyntaxTree(JsonSyntaxTree &tree) const
Use MOOSE Factories to construct a parameter tree for documentation or echoing input.
Definition: Builder.C:419
SONDefinitionFormatter::toString
std::string toString(const nlohmann::json &root)
returns a string representation of the tree in input file format
Definition: SONDefinitionFormatter.C:24
MooseApp::_command_line
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1233
MooseApp::outputMachineReadableData
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...
Definition: MooseApp.C:3651
JsonInputFileFormatter
This class produces produces a dump of the InputParameters that appears like the normal input file sy...
Definition: JsonInputFileFormatter.h:19
Moose::Capabilities::getCapabilityRegistry
static Capabilities & getCapabilityRegistry()
Definition: Capabilities.C:22
MooseApp::_distributed_mesh_on_command_line
bool _distributed_mesh_on_command_line
This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh...
Definition: MooseApp.h:1315
MooseApp::_builder
Moose::Builder _builder
Builder for building app related parser tree.
Definition: MooseApp.h:1239
MooseApp::_output_file_base
std::string _output_file_base
The output file basename.
Definition: MooseApp.h:1193
MooseApp::_output_buffer_cache
std::streambuf * _output_buffer_cache
Cache output buffer so the language server can turn it off then back on.
Definition: MooseApp.h:1587
ActionWarehouse::allActionBlocks
const std::vector< std::shared_ptr< Action > > & allActionBlocks() const
Returns a reference to all of the actions.
Definition: ActionWarehouse.C:187
ActionWarehouse::build
void build()
Builds all auto-buildable tasks.
Definition: ActionWarehouse.C:53
Moose::setColorConsole
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
Definition: Moose.C:766
MooseApp::header
virtual std::string header() const
Returns a string to be printed at the beginning of a simulation.
Definition: MooseApp.C:2989
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseApp::_has_kokkos_objects
bool _has_kokkos_objects
Flag whether there is any Kokkos object added by actions.
Definition: MooseApp.h:1650
MooseApp::getInputFileNames
const std::vector< std::string > & getInputFileNames() const
Definition: MooseApp.C:1733
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
JsonInputFileFormatter::toString
std::string toString(const nlohmann::json &root)
Returns a string representation of the tree in input file format.
Definition: JsonInputFileFormatter.C:18
MooseApp::getPrintableVersion
std::string getPrintableVersion() const
Non-virtual method for printing out the version string in a consistent format.
Definition: MooseApp.C:1266
ActionWarehouse::getActions
std::vector< const T * > getActions()
Retrieve all actions in a specific type ordered by their names.
Definition: ActionWarehouse.h:155
MooseApp::createMinimalApp
void createMinimalApp()
Method for creating the minimum required actions for an application (no input file) ...
Definition: MooseApp.C:3007
MooseApp::_ready_to_exit
bool _ready_to_exit
Definition: MooseApp.h:1304
MooseBase::isParamSetByUser
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.
Definition: MooseBase.h:205
MooseApp::_split_mesh
bool _split_mesh
Whether or not we are performing a split mesh operation (–split-mesh)
Definition: MooseApp.h:1324
CommonOutputAction
Meta-action for creating common output object parameters This action serves two purpose, first it adds common output object parameters.
Definition: CommonOutputAction.h:25
MooseApp::_early_exit_param
std::string _early_exit_param
Indicates if simulation is ready to exit, and keeps track of which param caused it to exit...
Definition: MooseApp.h:1303

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

Referenced by run().

2290 {
2291  if (getParam<bool>("show_inputs"))
2292  {
2293  const auto show_inputs_syntax = _pars.getCommandLineMetadata("show_inputs").switches;
2294  std::vector<std::string> dirs;
2295  const auto installable_inputs = getInstallableInputs();
2296 
2297  if (installable_inputs == "")
2298  {
2299  Moose::out
2300  << "Show inputs has not been overriden in this application.\nContact the developers of "
2301  "this appication and request that they override \"MooseApp::getInstallableInputs\".\n";
2302  }
2303  else
2304  {
2305  mooseAssert(!show_inputs_syntax.empty(), "show_inputs sytnax should not be empty");
2306 
2307  MooseUtils::tokenize(installable_inputs, dirs, 1, " ");
2308  Moose::out << "The following directories are installable into a user-writeable directory:\n\n"
2309  << installable_inputs << '\n'
2310  << "\nTo install one or more directories of inputs, execute the binary with the \""
2311  << show_inputs_syntax[0] << "\" flag. e.g.:\n$ "
2312  << _command_line->getExecutableName() << ' ' << show_inputs_syntax[0] << ' '
2313  << dirs[0] << '\n';
2314  }
2315  return true;
2316  }
2317  return false;
2318 }
MooseApp::getInstallableInputs
virtual std::string getInstallableInputs() const
Method to retrieve the installable inputs from a given applications <app>Revision.h file.
Definition: MooseApp.C:2321
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
MooseUtils::tokenize
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseStringUtils.h:55
MooseApp::_command_line
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1233
InputParameters::getCommandLineMetadata
const InputParameters::CommandLineMetadata & getCommandLineMetadata(const std::string &name) const
Definition: InputParameters.C:1039
InputParameters::CommandLineMetadata::switches
std::vector< std::string > switches
The switches for the parameter (i.e., [-t, –timing])
Definition: InputParameters.h:91

◆ solutionInvalidity() [1/2]

SolutionInvalidity& MooseApp::solutionInvalidity ( )
inline

Get the SolutionInvalidity for this app.

Definition at line 179 of file MooseApp.h.

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

179 { return _solution_invalidity; }
MooseApp::_solution_invalidity
SolutionInvalidity & _solution_invalidity
The SolutionInvalidity object for this application.
Definition: MooseApp.h:1254

◆ solutionInvalidity() [2/2]

const SolutionInvalidity& MooseApp::solutionInvalidity ( ) const
inline

Definition at line 180 of file MooseApp.h.

180 { return _solution_invalidity; }
MooseApp::_solution_invalidity
SolutionInvalidity & _solution_invalidity
The SolutionInvalidity object for this application.
Definition: MooseApp.h:1254

◆ syntax()

Syntax& MooseApp::syntax ( )
inline

Returns a writable reference to the syntax object.

Definition at line 225 of file MooseApp.h.

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

225 { return _syntax; }
MooseApp::_syntax
Syntax _syntax
Syntax of the input file.
Definition: MooseApp.h:1214

◆ testCheckpointHalfTransient()

bool MooseApp::testCheckpointHalfTransient ( ) const
inline

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

Definition at line 518 of file MooseApp.h.

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

518 { return _test_checkpoint_half_transient; }
MooseApp::_test_checkpoint_half_transient
const bool _test_checkpoint_half_transient
Whether or not this simulation should only run half its transient (useful for testing recovery) ...
Definition: MooseApp.h:1339

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

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

524 { return _test_restep; }
MooseApp::_test_restep
const bool _test_restep
Whether or not this simulation should fail its middle timestep and repeat (for testing) ...
Definition: MooseApp.h:1341

◆ theWarehouse()

TheWarehouse& MooseApp::theWarehouse ( )
inline

Definition at line 137 of file MooseApp.h.

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

137 { return *_the_warehouse; }
MooseApp::_the_warehouse
std::unique_ptr< TheWarehouse > _the_warehouse
The combined warehouse for storing any MooseObject based object.
Definition: MooseApp.h:1552

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name) const
protectedinherited
Returns
The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

48 {
49  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
50 }
PerfGraphInterface::_prefix
const std::string _prefix
A prefix to use for all sections.
Definition: PerfGraphInterface.h:127

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

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

94  {
95  mooseAssert(_type.size(), "Empty type");
96  return _type;
97  }
MooseBase::_type
const std::string & _type
The type of this class.
Definition: MooseBase.h:360

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

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

58 {
59  return type() + std::string(" \"") + name() + std::string("\"");
60 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

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

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

70 {
71  if (!_pars.have_parameter<std::string>(unique_name_param))
72  mooseError("uniqueName(): Object does not have a unique name");
73  return MooseObjectName(_pars.get<std::string>(unique_name_param));
74 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2270
MooseBase::unique_name_param
static const std::string unique_name_param
The name of the parameter that contains the unique object name.
Definition: MooseBase.h:57
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition: InputParameters.h:2329
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
MooseObjectName
A class for storing the names of MooseObject by tag and object name.
Definition: MooseObjectName.h:40

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

64 {
65  return MooseObjectParameterName(getBase(), name(), parameter_name);
66 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseObjectParameterName
A class for storing an input parameter name.
Definition: MooseObjectParameterName.h:26
MooseBase::getBase
const std::string & getBase() const
Definition: MooseBase.h:147

◆ unusedFlagIsError()

bool MooseApp::unusedFlagIsError ( ) const
inline

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

Definition at line 1074 of file MooseApp.h.

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

1074 { return _enable_unused_check == ERROR_UNUSED; }
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check

◆ unusedFlagIsWarning()

bool MooseApp::unusedFlagIsWarning ( ) const
inline

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

Definition at line 1071 of file MooseApp.h.

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

1071 { return _enable_unused_check == WARN_UNUSED; }
MooseApp::_enable_unused_check
enum MooseApp::UNUSED_CHECK _enable_unused_check

◆ useEigenvalue()

bool& MooseApp::useEigenvalue ( )
inline

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

Definition at line 396 of file MooseApp.h.

Referenced by CreateProblemDefaultAction::act().

396 { return _use_eigen_value; }
MooseApp::_use_eigen_value
bool _use_eigen_value
Boolean to indicate whether to use an eigenvalue executioner.
Definition: MooseApp.h:1288

◆ useExecutor()

bool MooseApp::useExecutor ( ) const
inline

Definition at line 337 of file MooseApp.h.

337 { return _use_executor; }
MooseApp::_use_executor
const bool _use_executor
Indicates whether we are operating in the new/experimental executor mode instead of using the legacy ...
Definition: MooseApp.h:1279

◆ useMasterMesh()

bool MooseApp::useMasterMesh ( ) const
inline

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

Definition at line 825 of file MooseApp.h.

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

825 { return _use_master_mesh; }
MooseApp::_use_master_mesh
const bool _use_master_mesh
Whether to use the parent app mesh for this app.
Definition: MooseApp.h:1561

◆ useNonlinear()

bool& MooseApp::useNonlinear ( )
inline

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

Definition at line 391 of file MooseApp.h.

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

391 { return _use_nonlinear; }
MooseApp::_use_nonlinear
bool _use_nonlinear
Boolean to indicate whether to use a Nonlinear or EigenSystem (inspected by actions) ...
Definition: MooseApp.h:1285

◆ validParams()

InputParameters MooseApp::validParams ( )
static

Definition at line 108 of file MooseApp.C.

109 {
110  InputParameters params = MooseBase::validParams();
111 
112  MooseApp::addAppParam(params);
113  MooseApp::addInputParam(params);
114 
115  params.addCommandLineParam<bool>("display_version", "-v --version", "Print application version");
116 
117  params.addOptionalValuedCommandLineParam<std::string>(
118  "mesh_only",
119  "--mesh-only <optional path>",
120  "",
121  "Build and output the mesh only (Default: \"<input_file_name>_in.e\")");
122  params.addOptionalValuedCommandLineParam<std::string>(
123  "csg_only",
124  "--csg-only <optional path>",
125  "",
126  "Setup and output the input mesh in CSG format only (Default: "
127  "\"<input_file_name>_out_csg.json\")");
128  params.addCommandLineParam<bool>(
129  "show_input", "--show-input", "Shows the parsed input file before running the simulation");
130  params.setGlobalCommandLineParam("show_input");
131  params.addCommandLineParam<bool>(
132  "show_outputs", "--show-outputs", "Shows the output execution time information");
133  params.setGlobalCommandLineParam("show_outputs");
134  params.addCommandLineParam<bool>(
135  "show_controls", "--show-controls", "Shows the Control logic available and executed");
136  params.setGlobalCommandLineParam("show_controls");
137 
138  params.addCommandLineParam<bool>(
139  "no_color", "--no-color", "Disable coloring of all Console outputs");
140  params.setGlobalCommandLineParam("no_color");
141 
142  MooseEnum colors("auto on off", "on");
143  params.addCommandLineParam<MooseEnum>(
144  "color", "--color <auto,on,off=on>", colors, "Whether to use color in console output");
145  params.setGlobalCommandLineParam("color");
146 
147  params.addCommandLineParam<bool>("help", "-h --help", "Displays CLI usage statement");
148  params.addCommandLineParam<bool>(
149  "minimal",
150  "--minimal",
151  "Ignore input file and build a minimal application with Transient executioner");
152 
153  params.addCommandLineParam<bool>(
154  "language_server",
155  "--language-server",
156  "Starts a process to communicate with development tools using the language server protocol");
157 
158  params.addCommandLineParam<bool>(
159  "definition", "--definition", "Shows a SON style input definition dump for input validation");
160  params.addCommandLineParam<bool>("dump", "--dump", "Shows a dump of available input file syntax");
161  params.addCommandLineParam<std::string>(
162  "dump_search",
163  "--dump-search <search>",
164  "Shows a dump of available input syntax matching a search");
165  params.addCommandLineParam<bool>("registry", "--registry", "Lists all known objects and actions");
166  params.addCommandLineParam<bool>(
167  "registry_hit", "--registry-hit", "Lists all known objects and actions in hit format");
168  params.addCommandLineParam<bool>(
169  "use_executor", "--executor", "Use the new Executor system instead of Executioners");
170 
171  params.addCommandLineParam<bool>(
172  "show_type", "--show-type", "Return the name of the application object");
173  params.addCommandLineParam<bool>("yaml", "--yaml", "Dumps all input file syntax in YAML format");
174  params.addCommandLineParam<std::string>(
175  "yaml_search", "--yaml-search", "Dumps input file syntax matching a search in YAML format");
176  params.addCommandLineParam<bool>("json", "--json", "Dumps all input file syntax in JSON format");
177  params.addCommandLineParam<std::string>(
178  "json_search", "--json-search", "Dumps input file syntax matching a search in JSON format");
179  params.addCommandLineParam<bool>(
180  "syntax", "--syntax", "Dumps the associated Action syntax paths ONLY");
181  params.addCommandLineParam<bool>(
182  "show_docs", "--docs", "Print url/path to the documentation website");
183  params.addCommandLineParam<bool>(
184  "show_capabilities", "--show-capabilities", "Dumps the capability registry in JSON format.");
185  params.addCommandLineParam<std::string>(
186  "required_capabilities",
187  "--required-capabilities",
188  "A list of conditions that is checked against the registered capabilities (see "
189  "--show-capabilities). The executable will terminate early if the conditions are not met.");
190  params.addCommandLineParam<std::string>(
191  "check_capabilities",
192  "--check-capabilities",
193  "A list of conditions that is checked against the registered capabilities. Will exit based "
194  "on whether or not the capaiblities are fulfilled. Does not check dynamically loaded apps.");
195  params.addCommandLineParam<bool>("check_input",
196  "--check-input",
197  "Check the input file (i.e. requires -i <filename>) and quit");
198  params.setGlobalCommandLineParam("check_input");
199  params.addCommandLineParam<bool>(
200  "show_inputs",
201  "--show-copyable-inputs",
202  "Shows the directories able to be copied into a user-writable location");
203 
204  params.addCommandLineParam<std::string>(
205  "copy_inputs",
206  "--copy-inputs <dir>",
207  "Copies installed inputs (e.g. tests, examples, etc.) to a directory <appname>_<dir>");
208  // TODO: Should this remain a bool? It can't be a regular argument because it contains
209  // values that have dashes in it, so it'll get treated as another arg
210  params.addOptionalValuedCommandLineParam<std::string>(
211  "run",
212  "--run <test harness args>",
213  "",
214  "Runs the inputs in the current directory copied to a "
215  "user-writable location by \"--copy-inputs\"");
216 
217  params.addCommandLineParam<bool>(
218  "list_constructed_objects",
219  "--list-constructed-objects",
220  "List all moose object type names constructed by the master app factory");
221 
222  params.addCommandLineParam<unsigned int>(
223  "n_threads", "--n-threads=<n>", "Runs the specified number of threads per process");
224  // This probably shouldn't be global, but the implications of removing this are currently
225  // unknown and we need to manage it with libmesh better
226  params.setGlobalCommandLineParam("n_threads");
227 
228  params.addCommandLineParam<bool>("allow_unused",
229  "-w --allow-unused",
230  "Warn about unused input file options instead of erroring");
231  params.setGlobalCommandLineParam("allow_unused");
232  params.addCommandLineParam<bool>(
233  "error_unused", "-e --error-unused", "Error when encountering unused input file options");
234  params.setGlobalCommandLineParam("error_unused");
235  params.addCommandLineParam<bool>(
236  "error_override",
237  "-o --error-override",
238  "Error when encountering overridden or parameters supplied multiple times");
239  params.setGlobalCommandLineParam("error_override");
240  params.addCommandLineParam<bool>(
241  "error_deprecated", "--error-deprecated", "Turn deprecated code messages into Errors");
242  params.setGlobalCommandLineParam("error_deprecated");
243 
244  params.addCommandLineParam<bool>("distributed_mesh",
245  "--distributed-mesh",
246  "Forces the use of a distributed finite element mesh");
247  // Would prefer that this parameter isn't global, but we rely on it too much
248  // in tests to be able to go back on that decision now
249  params.setGlobalCommandLineParam("distributed_mesh");
250 
251  params.addCommandLineParam<std::string>(
252  "split_mesh",
253  "--split-mesh <splits>",
254  "Comma-separated list of numbers of chunks to split the mesh into");
255 
256  // TODO: remove the logic now that this is global
257  params.addCommandLineParam<std::string>(
258  "split_file", "--split-file <filename>", "Name of split mesh file(s) to write/read");
259 
260  params.addCommandLineParam<bool>("use_split", "--use-split", "Use split distributed mesh files");
261 
262  params.addCommandLineParam<unsigned int>(
263  "refinements", "-r <num refinements>", "Specify additional initial uniform mesh refinements");
264 
265  params.addOptionalValuedCommandLineParam<std::string>(
266  "recover",
267  "--recover <optional file base>",
268  "",
269  "Continue the calculation. Without <file base>, the most recent recovery file will be used");
270  params.setGlobalCommandLineParam("recover");
271  params.addCommandLineParam<bool>(
272  "force_restart",
273  "--force-restart",
274  "Forcefully load checkpoints despite possible incompatibilities");
275  params.setGlobalCommandLineParam("force_restart");
276 
277  params.addCommandLineParam<bool>("suppress_header",
278  "--suppress-header",
279  false,
280  "Disables the output of the application header.");
281  params.setGlobalCommandLineParam("suppress_header");
282 
283  params.addCommandLineParam<bool>(
284  "test_checkpoint_half_transient",
285  "--test-checkpoint-half-transient",
286  "Run half of a transient with checkpoints enabled; used by the TestHarness");
287  params.setGlobalCommandLineParam("test_checkpoint_half_transient");
288 
289  params.addCommandLineParam<bool>("test_restep",
290  "--test-restep",
291  "Test re-running the middle timestep; used by the TestHarness");
292 
293  params.addCommandLineParam<bool>(
294  "trap_fpe",
295  "--trap-fpe",
296  "Enable floating point exception handling in critical sections of code"
297 #ifdef DEBUG
298  " (automatic due to debug build)"
299 #endif
300  );
301  params.setGlobalCommandLineParam("trap_fpe");
302 
303  params.addCommandLineParam<bool>(
304  "no_trap_fpe",
305  "--no-trap-fpe",
306  "Disable floating point exception handling in critical sections of code"
307 #ifndef DEBUG
308  " (unused due to non-debug build)"
309 #endif
310  );
311 
312  params.setGlobalCommandLineParam("no_trap_fpe");
313 
314  params.addCommandLineParam<bool>(
315  "no_gdb_backtrace", "--no-gdb-backtrace", "Disables gdb backtraces.");
316  params.setGlobalCommandLineParam("no_gdb_backtrace");
317 
318  params.addCommandLineParam<bool>("error", "--error", "Turn all warnings into errors");
319  params.setGlobalCommandLineParam("error");
320 
321  params.addCommandLineParam<bool>("timing",
322  "-t --timing",
323  "Enable all performance logging for timing; disables screen "
324  "output of performance logs for all Console objects");
325  params.setGlobalCommandLineParam("timing");
326  params.addCommandLineParam<bool>(
327  "no_timing", "--no-timing", "Disabled performance logging; overrides -t or --timing");
328  params.setGlobalCommandLineParam("no_timing");
329 
330  params.addCommandLineParam<bool>(
331  "allow_test_objects", "--allow-test-objects", "Register test objects and syntax");
332  params.setGlobalCommandLineParam("allow_test_objects");
333 
334  // Options ignored by MOOSE but picked up by libMesh, these are here so that they are displayed in
335  // the application help
336  params.addCommandLineParam<bool>(
337  "keep_cout",
338  "--keep-cout",
339  "Keep standard output from all processors when running in parallel");
340  params.setGlobalCommandLineParam("keep_cout");
341  params.addCommandLineParam<bool>(
342  "redirect_stdout",
343  "--redirect-stdout",
344  "Keep standard output from all processors when running in parallel");
345  params.setGlobalCommandLineParam("redirect_stdout");
346 
347  params.addCommandLineParam<std::string>(
348  "timpi_sync",
349  "--timpi-sync <type=nbx>",
350  "nbx",
351  "Changes the sync type used in spare parallel communitations within TIMPI");
352  params.setGlobalCommandLineParam("timpi_sync");
353 
354  // Options for debugging
355  params.addCommandLineParam<std::string>("start_in_debugger",
356  "--start-in-debugger <debugger>",
357  "Start the application and attach a debugger; this will "
358  "launch xterm windows using <debugger>");
359 
360  params.addCommandLineParam<unsigned int>(
361  "stop_for_debugger",
362  "--stop-for-debugger <seconds>",
363  "Pauses the application during startup for <seconds> to allow for connection of debuggers");
364 
365  params.addCommandLineParam<bool>(
366  "perf_graph_live_all", "--perf-graph-live-all", "Forces printing of ALL progress messages");
367  params.setGlobalCommandLineParam("perf_graph_live_all");
368 
369  params.addCommandLineParam<bool>(
370  "disable_perf_graph_live", "--disable-perf-graph-live", "Disables PerfGraph live printing");
371  params.setGlobalCommandLineParam("disable_perf_graph_live");
372 
373  params.addParam<bool>(
374  "automatic_automatic_scaling", false, "Whether to turn on automatic scaling by default");
375 
376  const MooseEnum compute_device_type("cpu cuda mps hip ceed-cpu ceed-cuda ceed-hip", "cpu");
377  params.addCommandLineParam<MooseEnum>(
378  "compute_device",
379  "--compute-device",
380  compute_device_type,
381  "The device type we want to run accelerated (libtorch, MFEM) computations on.");
382 
383 #ifdef HAVE_GPERFTOOLS
384  params.addCommandLineParam<std::string>(
385  "gperf_profiler_on",
386  "--gperf-profiler-on <ranks>",
387  "To generate profiling report only on comma-separated list of MPI ranks");
388 #endif
389 
390  params.addCommandLineParam<bool>(
391  "show_data_params",
392  "--show-data-params",
393  false,
394  "Show found paths for all DataFileName parameters in the header");
395  params.addCommandLineParam<bool>("show_data_paths",
396  "--show-data-paths",
397  false,
398  "Show registered data paths for searching in the header");
399 
400  params.addPrivateParam<std::shared_ptr<CommandLine>>("_command_line");
401  params.addPrivateParam<std::shared_ptr<Parallel::Communicator>>("_comm");
402  params.addPrivateParam<unsigned int>("_multiapp_level");
403  params.addPrivateParam<unsigned int>("_multiapp_number");
404  params.addPrivateParam<bool>("_use_master_mesh", false);
405  params.addPrivateParam<const MooseMesh *>("_master_mesh");
406  params.addPrivateParam<const MooseMesh *>("_master_displaced_mesh");
407  params.addPrivateParam<std::unique_ptr<Backup> *>("_initial_backup", nullptr);
408  params.addPrivateParam<std::shared_ptr<Parser>>("_parser");
409 #ifdef MOOSE_MFEM_ENABLED
410  params.addPrivateParam<std::shared_ptr<mfem::Device>>("_mfem_device");
411  params.addPrivateParam<std::set<std::string>>("_mfem_devices");
412 #endif
413 
414  params.addParam<bool>(
415  "use_legacy_material_output",
416  true,
417  "Set false to allow material properties to be output on INITIAL, not just TIMESTEP_END.");
418  params.addParam<bool>(
419  "use_legacy_initial_residual_evaluation_behavior",
420  true,
421  "The legacy behavior performs an often times redundant residual evaluation before the "
422  "solution modifying objects are executed prior to the initial (0th nonlinear iteration) "
423  "residual evaluation. The new behavior skips that redundant residual evaluation unless the "
424  "parameter Executioner/use_pre_SMO_residual is set to true.");
425 
426  params.addParam<bool>(
427  MeshGeneratorSystem::allow_data_driven_param,
428  false,
429  "Set true to enable data-driven mesh generation, which is an experimental feature");
430 
431  params.addCommandLineParam<bool>(
432  "parse_neml2_only",
433  "--parse-neml2-only",
434  "Executes the [NEML2] block to parse the input file and terminate.");
435 
436  MooseApp::addAppParam(params);
437 
438  params.registerBase("Application");
439 
440  return params;
441 }
InputParameters::setGlobalCommandLineParam
void setGlobalCommandLineParam(const std::string &name)
Sets the command line parameter with name as global.
Definition: InputParameters.C:1013
InputParameters::addPrivateParam
void addPrivateParam(const std::string &name, const T &value)
These method add a parameter to the InputParameters object which can be retrieved like any other para...
Definition: InputParameters.h:1962
MooseApp::addInputParam
static void addInputParam(InputParameters &params)
Definition: MooseApp.C:101
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:66
InputParameters::registerBase
void registerBase(const std::string &value)
This method must be called from every base "Moose System" to create linkage with the Action System...
Definition: InputParameters.C:484
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:92
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
InputParameters::addCommandLineParam
void addCommandLineParam(const std::string &name, const std::string &syntax, const std::string &doc_string)
Definition: InputParameters.h:1987
MooseApp::addAppParam
static void addAppParam(InputParameters &params)
Definition: MooseApp.C:94
InputParameters::addParam
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
Definition: InputParameters.h:1768
MeshGeneratorSystem::allow_data_driven_param
static const std::string allow_data_driven_param
The name of the boolean parameter on the MooseApp that will enable data driven generation.
Definition: MeshGeneratorSystem.h:39
InputParameters::addOptionalValuedCommandLineParam
void addOptionalValuedCommandLineParam(const std::string &name, const std::string &syntax, const T &value, const std::string &doc_string)
Add a command line parameter with an optional value.
Definition: InputParameters.h:2021
MooseBase::validParams
static InputParameters validParams()
Definition: MooseBase.C:28

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

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

2670 {
2671  if (processor_id() != 0)
2672  mooseError("MooseApp::writeRestartableMetaData(): Should only run on processor 0");
2673 
2674  const auto & map_name = getRestartableDataMapName(name);
2675  const auto meta_data_folder_base = metaDataFolderBase(folder_base, map_name);
2676 
2677  RestartableDataWriter writer(*this, getRestartableDataMap(name));
2678  return writer.write(meta_data_folder_base);
2679 }
MooseApp::metaDataFolderBase
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)
Definition: MooseApp.C:3162
RestartableDataWriter
Writer for restartable data, to be read by the RestartableDataReader.
Definition: RestartableDataWriter.h:17
MooseApp::processor_id
processor_id_type processor_id() const
Returns the MPI processor ID of the current processor.
Definition: MooseApp.h:411
MooseApp::getRestartableDataMap
RestartableDataMap & getRestartableDataMap(const RestartableDataMapName &name)
Return a reference to restartable data for the specific type flag.
Definition: MooseApp.C:3543
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp::getRestartableDataMapName
const std::string & getRestartableDataMapName(const RestartableDataMapName &name) const
Definition: MooseApp.C:3570
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271

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

2683 {
2684  std::vector<std::filesystem::path> paths;
2685 
2686  if (processor_id() == 0)
2687  for (const auto & name_map_pair : _restartable_meta_data)
2688  {
2689  const auto map_paths = writeRestartableMetaData(name_map_pair.first, folder_base);
2690  paths.insert(paths.end(), map_paths.begin(), map_paths.end());
2691  }
2692 
2693  return paths;
2694 }
MooseApp::_restartable_meta_data
std::unordered_map< RestartableDataMapName, std::pair< RestartableDataMap, std::string > > _restartable_meta_data
General storage for custom RestartableData that can be added to from outside applications.
Definition: MooseApp.h:1542
MooseApp::writeRestartableMetaData
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.
Definition: MooseApp.C:2668
MooseApp::processor_id
processor_id_type processor_id() const
Returns the MPI processor ID of the current processor.
Definition: MooseApp.h:411

Friends And Related Function Documentation

◆ FEProblemBase

friend class FEProblemBase
friend

Definition at line 1627 of file MooseApp.h.

◆ Restartable

friend class Restartable
friend

Definition at line 1628 of file MooseApp.h.

◆ SubProblem

friend class SubProblem
friend

Definition at line 1629 of file MooseApp.h.

Member Data Documentation

◆ _action_factory

ActionFactory MooseApp::_action_factory
protected

The Factory responsible for building Actions.

Definition at line 1221 of file MooseApp.h.

Referenced by createMinimalApp(), and getActionFactory().

◆ _action_warehouse

ActionWarehouse MooseApp::_action_warehouse
protected

Where built actions are stored.

Definition at line 1224 of file MooseApp.h.

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

◆ _app

MooseApp& MooseBase::_app
protectedinherited

The MOOSE application this is associated with.

Definition at line 357 of file MooseBase.h.

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

◆ _attached_relationship_managers

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

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

Definition at line 1354 of file MooseApp.h.

Referenced by attachRelationshipManagers().

◆ _automatic_automatic_scaling

const bool MooseApp::_automatic_automatic_scaling
private

Whether to turn on automatic scaling by default.

Definition at line 1590 of file MooseApp.h.

Referenced by defaultAutomaticScaling().

◆ _builder

Moose::Builder MooseApp::_builder
protected

Builder for building app related parser tree.

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

Referenced by getChainControlDataSystem().

◆ _check_input

bool MooseApp::_check_input
protected

true if we want to just check the input file

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

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

◆ _command_line

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

The CommandLine object.

Definition at line 1233 of file MooseApp.h.

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

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

◆ _cpu_profiling

bool MooseApp::_cpu_profiling = false
private

CPU profiling.

Definition at line 1593 of file MooseApp.h.

Referenced by ~MooseApp().

◆ _distributed_mesh_on_command_line

bool MooseApp::_distributed_mesh_on_command_line
protected

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

Definition at line 1315 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 1303 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 1301 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 1312 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 1584 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 1260 of file MooseApp.h.

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

◆ _executor

std::shared_ptr<Executor> MooseApp::_executor
protected

Pointer to the Executor of this run.

Definition at line 1263 of file MooseApp.h.

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

◆ _executor_params

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

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

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

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

◆ _exit_code

int MooseApp::_exit_code
protected

The exit code.

Definition at line 1306 of file MooseApp.h.

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

◆ _factory

Factory MooseApp::_factory
protected

Definition at line 1298 of file MooseApp.h.

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

◆ _file_base_set_by_user

bool MooseApp::_file_base_set_by_user
protected

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

Definition at line 1196 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 1275 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 1330 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 1211 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 1645 of file MooseApp.h.

Referenced by isKokkosAvailable().

◆ _has_kokkos_objects

bool MooseApp::_has_kokkos_objects = false
private

Flag whether there is any Kokkos object added by actions.

Definition at line 1650 of file MooseApp.h.

Referenced by hasKokkosObjects(), and setupOptions().

◆ _heap_profiling

bool MooseApp::_heap_profiling = false
private

Memory profiling.

Definition at line 1596 of file MooseApp.h.

Referenced by ~MooseApp().

◆ _initial_backup

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

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

Definition at line 1611 of file MooseApp.h.

Referenced by hasInitialBackup(), and restoreFromInitialBackup().

◆ _initial_from_file

bool MooseApp::_initial_from_file
protected

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

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

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

◆ _interface_registry

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

Registration for interface objects.

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

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

◆ _libtorch_device

const torch::DeviceType MooseApp::_libtorch_device
private

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

Definition at line 1615 of file MooseApp.h.

◆ _master_displaced_mesh

const MooseMesh* const MooseApp::_master_displaced_mesh
private

The displaced mesh from master app.

Definition at line 1567 of file MooseApp.h.

Referenced by masterDisplacedMesh().

◆ _master_mesh

const MooseMesh* const MooseApp::_master_mesh
private

The mesh from master app.

Definition at line 1564 of file MooseApp.h.

Referenced by masterMesh().

◆ _mesh_generator_system

MeshGeneratorSystem MooseApp::_mesh_generator_system
private

The system that manages the MeshGenerators.

Definition at line 1570 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 1620 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 1623 of file MooseApp.h.

Referenced by getMFEMDevices(), and setMFEMDevice().

◆ _multiapp_level

unsigned int MooseApp::_multiapp_level
private

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

Definition at line 1555 of file MooseApp.h.

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

◆ _multiapp_number

unsigned int MooseApp::_multiapp_number
private

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

Definition at line 1558 of file MooseApp.h.

Referenced by multiAppNumber().

◆ _name

const std::string& MooseBase::_name
protectedinherited

The name of this class.

Definition at line 363 of file MooseBase.h.

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

◆ _null_executor

std::shared_ptr<NullExecutor> MooseApp::_null_executor
protected

Used to return an executor that does nothing.

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

Referenced by setupOptions().

◆ _output_file_base

std::string MooseApp::_output_file_base
protected

The output file basename.

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

Referenced by getOutputFileNumbers(), and setOutputFileNumbers().

◆ _output_position

Point MooseApp::_output_position
protected

The output position.

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

Referenced by hasOutputPosition(), and setOutputPosition().

◆ _output_warehouse

OutputWarehouse MooseApp::_output_warehouse
protected

OutputWarehouse object for this App.

Definition at line 1227 of file MooseApp.h.

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

◆ _pars

const InputParameters& MooseBase::_pars
protectedinherited

The object's parameters.

Definition at line 366 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), 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 1230 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 1251 of file MooseApp.h.

Referenced by perfGraph(), and setupOptions().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app
protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _prefix

const std::string PerfGraphInterface::_prefix
protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _rank_map

const RankMap MooseApp::_rank_map
protected

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

Definition at line 1257 of file MooseApp.h.

Referenced by rankMap().

◆ _rd_reader

RestartableDataReader MooseApp::_rd_reader
private

Definition at line 1575 of file MooseApp.h.

Referenced by finalizeRestore(), and restore().

◆ _ready_to_exit

bool MooseApp::_ready_to_exit
protected

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

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

◆ _restart

bool MooseApp::_restart
protected

Whether or not this is a restart run.

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

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

◆ _restartable_meta_data

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

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

Definition at line 1542 of file MooseApp.h.

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

◆ _solution_invalidity

SolutionInvalidity& MooseApp::_solution_invalidity
protected

The SolutionInvalidity object for this application.

Definition at line 1254 of file MooseApp.h.

Referenced by solutionInvalidity().

◆ _split_mesh

bool MooseApp::_split_mesh
protected

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

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

Referenced by hasStartTime(), and setStartTime().

◆ _syntax

Syntax MooseApp::_syntax
protected

Syntax of the input file.

Definition at line 1214 of file MooseApp.h.

Referenced by setupOptions(), and syntax().

◆ _sys_info

SystemInfo MooseApp::_sys_info
protected

System Information.

Definition at line 1236 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 1602 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 1339 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 1341 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 1552 of file MooseApp.h.

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

◆ _trap_fpe

bool MooseApp::_trap_fpe
protected

Whether or not FPE trapping should be turned on.

Definition at line 1333 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 1187 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 1361 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 1288 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 1279 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 1561 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 1285 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 1327 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(), Factory::getValidParams(), ActionFactory::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 AddBCAction::act(), AddKernelAction::act(), AddNodalKernelAction::act(), AddMaterialAction::act(), AddFunctionAction::act(), MooseObject::isKokkosObject(), and setupOptions().

◆ MESH_META_DATA

const RestartableDataMapName MooseApp::MESH_META_DATA = "MeshMetaData"
static

Definition at line 130 of file MooseApp.h.

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

◆ MESH_META_DATA_SUFFIX

const RestartableDataMapName MooseApp::MESH_META_DATA_SUFFIX = "mesh"
static

Definition at line 131 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(), MooseObjectUnitTest::buildObjects(), ActionFactory::create(), 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:
Generated on Wed Nov 19 2025 20:11:21 for https://mooseframework.inl.gov by   doxygen 1.8.14