www.mooseframework.org
MooseApp.h
Go to the documentation of this file.
1 /****************************************************************/
2 /* DO NOT MODIFY THIS HEADER */
3 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
4 /* */
5 /* (c) 2010 Battelle Energy Alliance, LLC */
6 /* ALL RIGHTS RESERVED */
7 /* */
8 /* Prepared by Battelle Energy Alliance, LLC */
9 /* Under Contract No. DE-AC07-05ID14517 */
10 /* With the U. S. Department of Energy */
11 /* */
12 /* See COPYRIGHT for full restrictions */
13 /****************************************************************/
14 
15 #ifndef MOOSEAPP_H
16 #define MOOSEAPP_H
17 
18 // MOOSE includes
19 #include "Moose.h"
20 #include "Parser.h"
21 #include "ActionWarehouse.h"
22 #include "Factory.h"
23 #include "ActionFactory.h"
24 #include "OutputWarehouse.h"
25 #include "RestartableData.h"
26 #include "ConsoleStreamInterface.h"
27 
28 #include "libmesh/parallel_object.h"
29 
30 // C++ includes
31 #include <list>
32 #include <map>
33 #include <set>
34 
35 // Forward declarations
36 class Executioner;
37 class MooseApp;
38 class Backup;
39 class FEProblemBase;
40 class MeshModifier;
42 class SystemInfo;
43 class CommandLine;
44 
45 template <>
47 
58 class MooseApp : public ConsoleStreamInterface, public libMesh::ParallelObject
59 {
60 public:
61  virtual ~MooseApp();
62 
70  const std::string & name() const { return _name; }
71 
75  virtual std::string getPrintableName() const { return "Application"; }
76 
82 
88  const std::string & type() const { return _type; }
89 
91 
96  template <typename T>
97  const T & getParam(const std::string & name);
98 
99  template <typename T>
100  const T & getParam(const std::string & name) const;
102 
103  inline bool isParamValid(const std::string & name) const { return _pars.isParamValid(name); }
104 
108  virtual void run();
109 
113  std::string getFrameworkVersion() const;
114 
118  virtual std::string getVersion() const;
119 
123  std::string getPrintableVersion() const;
124 
128  virtual void setupOptions();
129 
131 
132  Parser & parser() { return _parser; }
133 
134  Syntax & syntax() { return _syntax; }
135 
139  void setInputFileName(std::string input_file_name);
140 
144  std::string getInputFileName() { return _input_filename; }
145 
149  void setOutputFileBase(std::string output_file_base) { _output_file_base = output_file_base; }
150 
154  std::string getOutputFileBase();
155 
159  void setOutputPosition(Point p);
160 
165  std::list<std::string> getCheckpointFiles();
166 
172 
178 
185  void setStartTime(const Real time);
186 
190  bool hasStartTime() { return _start_time_set; }
191 
195  Real getStartTime() { return _start_time; }
196 
201  void setGlobalTimeOffset(const Real offset) { _global_time_offset = offset; }
202 
208 
212  std::string getFileName(bool stripLeadingPath = true) const;
213 
218  void setCheckUnusedFlag(bool warn_is_error = false);
219 
223  void setErrorOverridden();
224 
228  void disableCheckUnusedFlag();
229 
234 
238  std::shared_ptr<Executioner> & executioner() { return _executioner; }
239 
243  bool & useNonlinear() { return _use_nonlinear; }
244 
248  bool & useEigenvalue() { return _use_eigen_value; }
249 
253  Factory & getFactory() { return _factory; }
254 
259 
265  std::shared_ptr<CommandLine> commandLine() { return _command_line; }
266 
271  bool & setFileRestart() { return _initial_from_file; }
272 
276  virtual void runInputFile();
277 
281  virtual void executeExecutioner();
282 
289 
294  {
295  mooseDeprecated("getParallelMeshOnCommandLine() is deprecated, call "
296  "getDistributedMeshOnCommandLine() instead.");
298  }
299 
303  bool isRecovering() const;
304 
308  bool isRestarting() const;
309 
313  bool hasRecoverFileBase();
314 
318  std::string getRecoverFileBase() { return _recover_base; }
319 
323  void setRecoverFileBase(std::string recover_base) { _recover_base = recover_base; }
324 
328  std::string getRecoverFileSuffix() { return _recover_suffix; }
329 
333  void setRecoverFileSuffix(std::string recover_suffix) { _recover_suffix = recover_suffix; }
334 
339  bool halfTransient() { return _half_transient; }
340 
349  void setOutputFileNumbers(std::map<std::string, unsigned int> numbers)
350  {
351  _output_file_numbers = numbers;
352  }
353 
361  std::map<std::string, unsigned int> & getOutputFileNumbers() { return _output_file_numbers; }
362 
367 
372 
377  const SystemInfo * getSystemInfo() const { return _sys_info.get(); }
378 
380 
385  void dynamicObjectRegistration(const std::string & app_name,
386  Factory * factory,
387  std::string library_path);
388  void dynamicAppRegistration(const std::string & app_name, std::string library_path);
389  void dynamicSyntaxAssociation(const std::string & app_name,
390  Syntax * syntax,
391  ActionFactory * action_factory,
392  std::string library_path);
394 
401  std::string appNameToLibName(const std::string & app_name) const;
402 
406  std::string libNameToAppName(const std::string & library_name) const;
407 
411  std::set<std::string> getLoadedLibraryPaths() const;
412 
417 
418  /*
419  * Register a piece of restartable data. This is data that will get
420  * written / read to / from a restart file.
421  *
422  * @param name The full (unique) name.
423  * @param data The actual data object.
424  * @param tid The thread id of the object. Use 0 if the object is not threaded.
425  */
426  virtual void
427  registerRestartableData(std::string name, RestartableDataValue * data, THREAD_ID tid);
428 
434 
439  std::set<std::string> & getRecoverableData() { return _recoverable_data; }
440 
445  std::shared_ptr<Backup> backup();
446 
454  void restore(std::shared_ptr<Backup> backup, bool for_restart = false);
455 
459  virtual std::string header() const;
460 
465  unsigned int multiAppLevel() const { return _multiapp_level; }
466 
471  unsigned int multiAppNumber() const { return _multiapp_number; }
472 
476  bool isUltimateMaster() { return !_multiapp_level; }
477 
481  void addMeshModifier(const std::string & modifier_name,
482  const std::string & name,
484 
488  const MeshModifier & getMeshModifier(const std::string & name) const;
489 
497  std::vector<std::string> getMeshModifierNames() const;
498 
502  void clearMeshModifiers();
503 
507  void executeMeshModifiers();
508 
510 
514  void setRestart(const bool & value);
515  void setRecover(const bool & value);
517 
519  bool checkInput() const { return _check_input; }
520 
521 protected:
525  bool hasCachedBackup() { return _cached_backup.get(); }
526 
530  void restoreCachedBackup();
531 
535  void dynamicRegistration(const Parameters & params);
536 
541  void loadLibraryAndDependencies(const std::string & library_filename, const Parameters & params);
542 
544  MooseApp(InputParameters parameters);
545 
547  virtual void meshOnly(std::string mesh_file_name);
548 
559  virtual void registerRecoverableData(std::string name);
560 
565  void errorCheck();
566 
568  std::string _name;
569 
572 
574  const std::string _type;
575 
577  const std::shared_ptr<Parallel::Communicator> _comm;
578 
580  std::string _input_filename;
581 
583  std::string _output_file_base;
584 
587 
590 
593 
596 
599 
601  std::shared_ptr<CommandLine> _command_line;
602 
605 
608 
611 
614 
617 
620 
622  std::shared_ptr<Executioner> _executioner;
623 
626 
629 
631  std::unique_ptr<SystemInfo> _sys_info;
632 
635  {
640 
642 
646 
649 
652 
654  bool _recover;
655 
657  bool _restart;
658 
660  std::string _recover_base;
661 
663  std::string _recover_suffix;
664 
667 
669  std::map<std::string, unsigned int> _output_file_numbers;
670 
673 
675  std::map<std::pair<std::string, std::string>, void *> _lib_handles;
676 
677 private:
702  void createMinimalApp();
703 
706 
708  std::set<std::string> _recoverable_data;
709 
712  {
716  };
717 
719  unsigned int _multiapp_level;
720 
722  unsigned int _multiapp_number;
723 
725  std::map<std::string, std::shared_ptr<MeshModifier>> _mesh_modifiers;
726 
728  std::shared_ptr<Backup> _cached_backup;
729 
730  // Allow FEProblemBase to set the recover/restart state, so make it a friend
731  friend class FEProblemBase;
732  friend class Restartable;
733  friend class SubProblem;
734 };
735 
736 template <typename T>
737 const T &
738 MooseApp::getParam(const std::string & name)
739 {
740  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
741 }
742 
743 template <typename T>
744 const T &
745 MooseApp::getParam(const std::string & name) const
746 {
747  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
748 }
749 
750 #endif /* MOOSEAPP_H */
virtual void registerRecoverableData(std::string name)
NOTE: This is an internal function meant for MOOSE use only!
Definition: MooseApp.C:678
bool _use_eigen_value
Boolean to indicate whether to use an eigenvalue executioner.
Definition: MooseApp.h:628
bool hasStartTime()
Definition: MooseApp.h:190
bool & useNonlinear()
Set a Boolean indicating whether this app will use a Nonlinear or Eigen System.
Definition: MooseApp.h:243
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
Definition: MooseApp.h:719
std::shared_ptr< Executioner > & executioner()
Retrieve the Executioner shared pointer for this App.
Definition: MooseApp.h:238
void setInputFileName(std::string input_file_name)
Set the input file name.
Definition: MooseApp.C:530
void setOutputFileBase(std::string output_file_base)
Override the selection of the output file base name.
Definition: MooseApp.h:149
static const T & getParamHelper(const std::string &name, const InputParameters &pars, const T *the_type)
const std::string _type
The string representation of the type of this object as registered (see registerApp(AppName)) ...
Definition: MooseApp.h:574
A class for creating restricted objects.
Definition: Restartable.h:31
bool _initial_from_file
This variable indicates when a request has been made to restart from an Exodus file.
Definition: MooseApp.h:648
Storage container for all InputParamter objects.
bool hasOutputPosition()
Whether or not an output position has been set.
Definition: MooseApp.h:171
void dynamicSyntaxAssociation(const std::string &app_name, Syntax *syntax, ActionFactory *action_factory, std::string library_path)
Definition: MooseApp.C:931
virtual void setupOptions()
Setup options based on InputParameters.
Definition: MooseApp.C:303
const std::string & type() const
Get the type of this object as a string.
Definition: MooseApp.h:88
RestartableDatas _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:705
bool & setFileRestart()
This method is here so we can determine whether or not we need to use a separate reader to read the m...
Definition: MooseApp.h:271
Real _global_time_offset
Offset of the local App time to the "global" problem time.
Definition: MooseApp.h:598
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:607
bool _output_position_set
Whether or not an output position has been set for this app.
Definition: MooseApp.h:586
Generic factory class for build all sorts of objects.
Definition: Factory.h:152
unsigned int multiAppLevel() const
The MultiApp Level.
Definition: MooseApp.h:465
std::set< std::string > _recoverable_data
Data names that will only be read from the restart file during RECOVERY.
Definition: MooseApp.h:708
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:712
Real getGlobalTimeOffset()
Each App has it&#39;s own local time.
Definition: MooseApp.h:207
std::list< std::string > getCheckpointFiles()
Extract all possible checkpoint file names.
Definition: MooseApp.C:779
InputParameters & parameters()
Get the parameters of the object.
Definition: MooseApp.h:81
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:1121
virtual std::string getPrintableName() const
Get printable name of the application.
Definition: MooseApp.h:75
bool _use_nonlinear
Boolean to indicate whether to use a Nonlinear or EigenSystem (inspected by actions) ...
Definition: MooseApp.h:625
void dynamicRegistration(const Parameters &params)
Helper method for dynamic loading of objects.
Definition: MooseApp.C:949
std::string getRecoverFileBase()
The file_base for the recovery file.
Definition: MooseApp.h:318
const SystemInfo * getSystemInfo() const
Get SystemInfo object.
Definition: MooseApp.h:377
virtual void run()
Run the application.
Definition: MooseApp.C:739
Real _start_time
The time at which to start the simulation.
Definition: MooseApp.h:595
void mooseDeprecated(Args &&...args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:202
MeshModifiers are objects that can modify or add to an existing mesh.
Definition: MeshModifier.h:31
Base class for MOOSE-based applications.
Definition: MooseApp.h:58
Storage for action instances.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
bool _check_input
true if we want to just check the input file
Definition: MooseApp.h:672
std::set< std::string > getLoadedLibraryPaths() const
Return the loaded library filenames in a std::vector.
Definition: MooseApp.C:1110
void setOutputFileNumbers(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 num...
Definition: MooseApp.h:349
bool halfTransient()
Whether or not this simulation should only run half its transient (useful for testing recovery) ...
Definition: MooseApp.h:339
Syntax _syntax
Syntax of the input file.
Definition: MooseApp.h:604
Syntax & syntax()
Definition: MooseApp.h:134
std::string libNameToAppName(const std::string &library_name) const
Converts a library name to an application name:
Definition: MooseApp.C:862
std::shared_ptr< Backup > _cached_backup
Cache for a Backup to use for restart / recovery.
Definition: MooseApp.h:728
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:669
void loadLibraryAndDependencies(const std::string &library_filename, const Parameters &params)
Recursively loads libraries and dependencies in the proper order to fully register a MOOSE applicatio...
Definition: MooseApp.C:985
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:616
std::unique_ptr< SystemInfo > _sys_info
System Information.
Definition: MooseApp.h:631
ActionFactory & getActionFactory()
Retrieve the ActionFactory associated with this App.
Definition: MooseApp.h:258
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:846
std::set< std::string > & getRecoverableData()
Return a reference to the recoverable data object.
Definition: MooseApp.h:439
const std::string & name() const
Get the name of the object.
Definition: MooseApp.h:70
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
void executeMeshModifiers()
Execute and clear the Mesh Modifiers data structure.
Definition: MooseApp.C:1159
bool _half_transient
Whether or not this simulation should only run half its transient (useful for testing recovery) ...
Definition: MooseApp.h:666
virtual void registerRestartableData(std::string name, RestartableDataValue *data, THREAD_ID tid)
Definition: MooseApp.C:874
Factory & getFactory()
Retrieve the Factory associated with this App.
Definition: MooseApp.h:253
std::string getPrintableVersion() const
Non-virtual method for printing out the version string in a consistent format.
Definition: MooseApp.C:297
This class wraps provides and tracks access to command line parameters.
Definition: CommandLine.h:36
std::string getOutputFileBase()
Override the selection of the output file base name.
Definition: MooseApp.C:536
std::shared_ptr< Backup > backup()
Create a Backup from the current App.
Definition: MooseApp.C:684
Parser _parser
Parser for parsing the input file.
Definition: MooseApp.h:619
bool _start_time_set
Whether or not an start time has been set.
Definition: MooseApp.h:592
std::string getFrameworkVersion() const
Returns the framework version.
Definition: MooseApp.C:285
void setRecoverFileSuffix(std::string recover_suffix)
mutator for recover_suffix
Definition: MooseApp.h:333
void restoreCachedBackup()
Restore from a cached backup.
Definition: MooseApp.C:1227
void addMeshModifier(const std::string &modifier_name, const std::string &name, InputParameters parameters)
Add a mesh modifier that will act on the meshes in the system.
Definition: MooseApp.C:1133
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.
bool & useEigenvalue()
Set a Boolean indicating whether this app will use an eigenvalue executioner.
Definition: MooseApp.h:248
void setErrorOverridden()
Set a flag so that the parser will throw an error if overridden parameters are detected.
Definition: MooseApp.C:733
std::shared_ptr< CommandLine > _command_line
Command line object.
Definition: MooseApp.h:601
bool _restart
Whether or not this is a restart run.
Definition: MooseApp.h:657
std::shared_ptr< CommandLine > commandLine()
Get the command line.
Definition: MooseApp.h:265
void setStartTime(const Real time)
Set the starting time for the simulation.
Definition: MooseApp.C:827
bool getParallelMeshOnCommandLine() const
Deprecated.
Definition: MooseApp.h:293
Real getStartTime()
Definition: MooseApp.h:195
bool hasRecoverFileBase()
Return true if the recovery file base is set.
Definition: MooseApp.C:619
Container for storing material properties.
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:70
An inteface for the _console for outputting to the Console object.
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:622
InputParameterWarehouse * _input_parameter_warehouse
Input parameter storage structure (this is a raw pointer so the destruction time can be explicitly co...
Definition: MooseApp.h:610
ActionFactory _action_factory
The Factory responsible for building Actions.
Definition: MooseApp.h:613
ActionWarehouse & actionWarehouse()
Definition: MooseApp.h:130
RegistrationType
Enumeration for holding the valid types of dynamic registrations allowed.
Definition: MooseApp.h:711
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:41
enum MooseApp::UNUSED_CHECK _enable_unused_check
bool _recover
Whether or not this is a recovery run.
Definition: MooseApp.h:654
Point _output_position
The output position.
Definition: MooseApp.h:589
void clearMeshModifiers()
Clear all mesh modifers.
Definition: MooseApp.C:1207
void setGlobalTimeOffset(const Real offset)
Each App has it&#39;s own local time.
Definition: MooseApp.h:201
bool _error_overridden
Indicates whether warnings or errors are displayed when overridden parameters are detected...
Definition: MooseApp.h:644
Parser & parser()
Definition: MooseApp.h:132
InputParameters validParams< MooseApp >()
Definition: MooseApp.C:60
Class for storing and utilizing output objects.
std::string _input_filename
Input file name used.
Definition: MooseApp.h:580
virtual std::string getVersion() const
Returns the current version of the framework or application (default: framework version).
Definition: MooseApp.C:291
bool checkInput() const
Returns whether the Application is running in check input mode.
Definition: MooseApp.h:519
std::map< std::pair< std::string, std::string >, void * > _lib_handles
The library, registration method and the handle to the method.
Definition: MooseApp.h:675
bool hasOutputWarehouse()
Return true if the output position has been set.
Definition: MooseApp.h:366
void setRestart(const bool &value)
Sets the restart/recover flags.
Definition: MooseApp.C:1213
UNUSED_CHECK
Indicates whether warnings, errors, or no output is displayed when unused parameters are detected...
Definition: MooseApp.h:634
void setRecoverFileBase(std::string recover_base)
mutator for recover_base (set by RecoverBaseAction)
Definition: MooseApp.h:323
std::map< std::string, unsigned int > & getOutputFileNumbers()
Store a map of outputter names and file numbers The MultiApp system requires this to get the file num...
Definition: MooseApp.h:361
InputParameters _pars
Parameters of this object.
Definition: MooseApp.h:571
Helper class to hold streams for Backup and Restore operations.
Definition: Backup.h:25
const T & getParam(const std::string &name)
Retrieve a parameter for the object.
Definition: MooseApp.h:738
virtual void meshOnly(std::string mesh_file_name)
Don&#39;t run the simulation, just complete all of the mesh preperation steps and exit.
Definition: MooseApp.C:625
virtual void executeExecutioner()
Execute the Executioner that was built.
Definition: MooseApp.C:585
void restore(std::shared_ptr< Backup > backup, bool for_restart=false)
Restore a Backup.
Definition: MooseApp.C:694
std::string _recover_base
The base name to recover from. If blank then we will find the newest recovery file.
Definition: MooseApp.h:660
bool _distributed_mesh_on_command_line
This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh...
Definition: MooseApp.h:651
bool hasCachedBackup()
Whether or not this MooseApp has cached a Backup to use for restart / recovery.
Definition: MooseApp.h:525
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:53
const RestartableDatas & getRestartableData()
Return reference to the restatable data object.
Definition: MooseApp.h:433
Point getOutputPosition()
Get the output position.
Definition: MooseApp.h:177
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:607
std::string _output_file_base
The output file basename.
Definition: MooseApp.h:583
bool getDistributedMeshOnCommandLine() const
Returns true if the user specified –distributed-mesh (or –parallel-mesh, for backwards compatibilit...
Definition: MooseApp.h:288
const std::shared_ptr< Parallel::Communicator > _comm
The MPI communicator this App is going to use.
Definition: MooseApp.h:577
std::string getInputFileName()
Returns the input file name that was set with setInputFileName.
Definition: MooseApp.h:144
bool isParamValid(const std::string &name) const
Definition: MooseApp.h:103
virtual void runInputFile()
Actually build everything in the input file.
Definition: MooseApp.C:542
Holding syntax for parsing input files.
Definition: Syntax.h:26
void setOutputPosition(Point p)
Tell the app to output in a specific position.
Definition: MooseApp.C:768
Factory _factory
Definition: MooseApp.h:641
Executioner * getExecutioner()
Retrieve the Executioner for this App.
Definition: MooseApp.h:233
std::string getRecoverFileSuffix()
The suffix for the recovery file.
Definition: MooseApp.h:328
bool isRestarting() const
Whether or not this is a "restart" calculation.
Definition: MooseApp.C:613
MooseApp(InputParameters parameters)
Constructor is protected so that this object is constructed through the AppFactory object...
Definition: MooseApp.C:218
std::string _name
The name of this object.
Definition: MooseApp.h:568
void dynamicAppRegistration(const std::string &app_name, std::string library_path)
Definition: MooseApp.C:885
unsigned int _multiapp_number
Numbering in all the sub-apps on the same level.
Definition: MooseApp.h:722
const MeshModifier & getMeshModifier(const std::string &name) const
Get a mesh modifier with its name.
Definition: MooseApp.C:1144
std::map< std::string, std::shared_ptr< MeshModifier > > _mesh_modifiers
Holds the mesh modifiers until they have completed, then this structure is cleared.
Definition: MooseApp.h:725
virtual std::string header() const
Returns a string to be printed at the beginning of a simulation.
Definition: MooseApp.C:1127
bool isUltimateMaster()
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:476
void createMinimalApp()
Method for creating the minimum required actions for an application (no input file) ...
Definition: MooseApp.C:1239
std::vector< std::string > getMeshModifierNames() const
Get names of all mesh modifiers Note: This function should be called after all mesh modifiers are add...
Definition: MooseApp.C:1150
bool _ready_to_exit
Definition: MooseApp.h:645
void setRecover(const bool &value)
Definition: MooseApp.C:1221
void disableCheckUnusedFlag()
Removes warnings and error checks for unrecognized variables in the input file.
Definition: MooseApp.C:727
std::string getFileName(bool stripLeadingPath=true) const
Return the filename that was parsed.
Definition: MooseApp.C:834
std::string _recover_suffix
The file suffix to recover from. If blank then we will use "cpr" for binary CheckpointIO.
Definition: MooseApp.h:663
void dynamicObjectRegistration(const std::string &app_name, Factory *factory, std::string library_path)
Thes methods are called to register applications or objects on demand.
Definition: MooseApp.C:915
Abstract definition of a RestartableData value.
Class for parsing input files.
Definition: Parser.h:120
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:840
virtual ~MooseApp()
Definition: MooseApp.C:270
unsigned int multiAppNumber() const
The MultiApp number.
Definition: MooseApp.h:471
unsigned int THREAD_ID
Definition: MooseTypes.h:79
void errorCheck()
Runs post-initialization error checking that cannot be run correctly unless the simulation has been f...
Definition: MooseApp.C:572