https://mooseframework.inl.gov
MooseApp.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #ifdef MOOSE_LIBTORCH_ENABLED
13 // Libtorch includes
14 #include <torch/types.h>
15 #include <torch/mps.h>
16 #include <torch/cuda.h>
17 #include <c10/core/DeviceType.h>
18 #endif
19 
20 #ifdef MOOSE_MFEM_ENABLED
21 #include "libmesh/ignore_warnings.h"
22 #include <mfem.hpp>
23 #include "libmesh/restore_warnings.h"
24 #endif
25 
26 // MOOSE includes
27 #include "Moose.h"
28 #include "Builder.h"
29 #include "ActionWarehouse.h"
30 #include "Factory.h"
31 #include "ActionFactory.h"
32 #include "OutputWarehouse.h"
33 #include "RestartableData.h"
34 #include "RestartableDataMap.h"
35 #include "ConsoleStreamInterface.h"
36 #include "PerfGraph.h"
37 #include "PerfGraphInterface.h"
38 #include "TheWarehouse.h"
39 #include "RankMap.h"
40 #include "MeshGeneratorSystem.h"
41 #include "ChainControlDataSystem.h"
42 #include "RestartableDataReader.h"
43 #include "Backup.h"
44 #include "MooseBase.h"
45 #include "Capabilities.h"
46 #include "MoosePassKey.h"
47 #include "SystemInfo.h"
48 #include "Syntax.h"
49 
50 #include "libmesh/parallel_object.h"
51 #include "libmesh/mesh_base.h"
52 #include "libmesh/point.h"
53 
54 // C++ includes
55 #include <list>
56 #include <map>
57 #include <set>
58 #include <unordered_set>
59 #include <typeindex>
60 #include <filesystem>
61 #include <variant>
62 
63 // Forward declarations
64 class Executioner;
65 class Executor;
66 class NullExecutor;
67 class FEProblemBase;
69 class CommandLine;
71 class SolutionInvalidity;
72 class MultiApp;
73 #ifdef MOOSE_MFEM_ENABLED
74 class MFEMProblemSolve;
75 #endif
76 
77 namespace libMesh
78 {
79 class ExodusII_IO;
80 }
81 namespace hit
82 {
83 class Node;
84 }
85 
97 {
98 public:
100  std::optional<MooseEnum> getComputeDevice() const;
101 
102 #ifdef MOOSE_LIBTORCH_ENABLED
103  torch::DeviceType getLibtorchDevice() const { return _libtorch_device; }
105 #endif
106 
113  {
118  std::vector<std::string> sub_transformed_vars;
120  std::vector<PostprocessorName> sub_transformed_pps;
121  };
122 
124  static const std::string MESH_META_DATA_SUFFIX;
125 
126  static InputParameters validParams();
127 
128  virtual ~MooseApp();
129 
131 
135  virtual std::string getPrintableName() const { return "Application"; }
136 
137  virtual std::string appBinaryName() const
138  {
140  name = name.substr(0, name.find_last_of("-"));
141  if (name.find_first_of("/") != std::string::npos)
142  name = name.substr(name.find_first_of("/") + 1, std::string::npos);
143  return name;
144  }
145 
150  int exitCode() const { return _exit_code; }
151 
155  void setExitCode(const int exit_code) { _exit_code = exit_code; }
156 
161  const RankMap & rankMap() { return _rank_map; }
162 
167 
175 
179  virtual void run();
180 
184  std::string getFrameworkVersion() const;
185 
189  virtual std::string getVersion() const;
190 
194  std::string getPrintableVersion() const;
195 
199  virtual void setupOptions();
200 
209 
214 
218  Syntax & syntax() { return _syntax; }
219 
223  const std::vector<std::string> & getInputFileNames() const;
224 
228  const std::string & getLastInputFileName() const;
229 
234  void setOutputFileBase(const std::string & output_file_base);
235 
246  std::string getOutputFileBase(bool for_non_moose_build_output = false) const;
247 
251  void setOutputPosition(const Point & p);
252 
257  std::list<std::string> getCheckpointDirectories() const;
258 
263  std::list<std::string> getCheckpointFiles() const;
264 
269  bool hasOutputPosition() const { return _output_position_set; }
270 
275  Point getOutputPosition() const { return _output_position; }
276 
283  void setStartTime(Real time);
284 
288  bool hasStartTime() const { return _start_time_set; }
289 
293  Real getStartTime() const { return _start_time; }
294 
299  void setGlobalTimeOffset(Real offset) { _global_time_offset = offset; }
300 
306 
312  std::string getFileName(bool stripLeadingPath = true) const;
313 
317  void setErrorOverridden();
318 
322  void disableCheckUnusedFlag();
323 
327  Executioner * getExecutioner() const;
328  Executor * getExecutor() const { return _executor.get(); }
329  NullExecutor * getNullExecutor() const { return _null_executor.get(); }
330  bool useExecutor() const { return _use_executor; }
331  FEProblemBase & feProblem() const;
332 
336  void setExecutioner(std::shared_ptr<Executioner> && executioner) { _executioner = executioner; }
337  void setExecutor(std::shared_ptr<Executor> && executor) { _executor = executor; }
338  void
339  addExecutor(const std::string & type, const std::string & name, const InputParameters & params);
340 
345  void addExecutorParams(const std::string & type,
346  const std::string & name,
347  const InputParameters & params);
348 
352  const Parser & parser() const;
354  Parser & parser();
356 
361  void createExecutors();
362 
370  Executor & getExecutor(const std::string & name, bool fail_if_not_found = true);
371 
380 
384  bool & useNonlinear() { return _use_nonlinear; }
385 
389  bool & useEigenvalue() { return _use_eigen_value; }
390 
394  Factory & getFactory() { return _factory; }
395 
400 
404  processor_id_type processor_id() const { return _comm->rank(); }
405 
411  std::shared_ptr<CommandLine> commandLine() const { return _command_line; }
412 
417  void setExodusFileRestart(bool flag) { _initial_from_file = flag; }
418 
423  bool getExodusFileRestart() const { return _initial_from_file; }
424 
428  void setExReaderForRestart(std::shared_ptr<libMesh::ExodusII_IO> && exreader)
429  {
430  _ex_reader = exreader;
431  }
432 
437 
441  virtual void runInputFile();
442 
446  virtual void executeExecutioner();
447 
454 
460  bool isRecovering() const;
461 
468  bool isRestarting() const;
469 
473  bool isSplitMesh() const;
474 
476 
479  bool hasRestartRecoverFileBase() const;
480  bool hasRecoverFileBase() const;
482 
484 
487  std::string getRestartRecoverFileBase() const { return _restart_recover_base; }
488  std::string getRecoverFileBase() const
489  {
490  mooseDeprecated("MooseApp::getRecoverFileBase is deprecated, use "
491  "MooseApp::getRestartRecoverFileBase() instead.");
492  return _restart_recover_base;
493  }
495 
499  void setRestartRecoverFileBase(const std::string & file_base)
500  {
501  if (file_base.empty())
503  else
504  _restart_recover_base = file_base;
505  }
506 
512 
517  bool testReStep() const { return _test_restep; }
518 
527  void setOutputFileNumbers(const std::map<std::string, unsigned int> & numbers)
528  {
529  _output_file_numbers = numbers;
530  }
531 
539  const std::map<std::string, unsigned int> & getOutputFileNumbers() const
540  {
541  return _output_file_numbers;
542  }
543 
548  const OutputWarehouse & getOutputWarehouse() const;
549 
554  const SystemInfo & getSystemInfo() const { return _sys_info; }
555 
557 
562  void dynamicAllRegistration(const std::string & app_name,
563  Factory * factory,
564  ActionFactory * action_factory,
565  Syntax * syntax,
566  std::string library_path,
567  const std::string & library_name);
568  void dynamicAppRegistration(const std::string & app_name,
569  std::string library_path,
570  const std::string & library_name,
571  bool lib_load_deps);
573 
580  std::string appNameToLibName(const std::string & app_name) const;
581 
585  std::string libNameToAppName(const std::string & library_name) const;
586 
590  std::set<std::string> getLoadedLibraryPaths() const;
591 
595  std::set<std::string> getLibrarySearchPaths(const std::string & library_path_from_param) const;
596 
601 
602  /*
603  * Register a piece of restartable data. This is data that will get
604  * written / read to / from a restart file.
605  *
606  * @param data The actual data object.
607  * @param tid The thread id of the object. Use 0 if the object is not threaded.
608  * @param read_only Restrict the data for read-only
609  * @param metaname (optional) register the data to the meta data storage (tid must be 0)
610  */
611  RestartableDataValue & registerRestartableData(std::unique_ptr<RestartableDataValue> data,
612  THREAD_ID tid,
613  bool read_only,
614  const RestartableDataMapName & metaname = "");
615 
616  /*
617  * Deprecated method to register a piece of restartable data.
618  *
619  * Use the call without a data name instead.
620  */
621  RestartableDataValue & registerRestartableData(const std::string & name,
622  std::unique_ptr<RestartableDataValue> data,
623  THREAD_ID tid,
624  bool read_only,
625  const RestartableDataMapName & metaname = "");
626 
627  /*
628  * Check if a restartable meta data exists or not.
629  *
630  * @param name The full (unique) name.
631  * @param metaname The name to the meta data storage
632  */
633  bool hasRestartableMetaData(const std::string & name,
634  const RestartableDataMapName & metaname) const;
635 
636  /*
637  * Retrieve restartable meta data from restartable data map
638  *
639  * @param name The full (unique) name.
640  * @param metaname The name to the meta data storage
641  * @return A reference to the restartable meta data value
642  */
643  RestartableDataValue & getRestartableMetaData(const std::string & name,
644  const RestartableDataMapName & metaname,
645  THREAD_ID tid);
646 
652  const std::filesystem::path & folder_base);
657  void loadRestartableMetaData(const std::filesystem::path & folder_base);
658 
664  std::vector<std::filesystem::path>
666  const std::filesystem::path & folder_base);
672  std::vector<std::filesystem::path>
673  writeRestartableMetaData(const std::filesystem::path & folder_base);
674 
679  const std::vector<RestartableDataMap> & getRestartableData() const { return _restartable_data; }
681  std::vector<RestartableDataMap> & getRestartableData() { return _restartable_data; }
683 
688 
693 
703  void registerRestartableDataMapName(const RestartableDataMapName & name, std::string suffix = "");
704 
708  const std::string & getRestartableDataMapName(const RestartableDataMapName & name) const;
709 
715 
721  std::vector<std::filesystem::path> backup(const std::filesystem::path & folder_base);
727  std::unique_ptr<Backup> backup();
728 
732  virtual void preBackup() {}
733 
745  void restore(const std::filesystem::path & folder_base, const bool for_restart);
746 
758  void restore(std::unique_ptr<Backup> backup, const bool for_restart);
759 
766  virtual void postRestore(const bool /* for_restart */) {}
767 
780  void restoreFromInitialBackup(const bool for_restart);
781 
791  std::unique_ptr<Backup> finalizeRestore();
792 
796  virtual std::string header() const;
797 
802  unsigned int multiAppLevel() const { return _multiapp_level; }
803 
808  unsigned int multiAppNumber() const { return _multiapp_number; }
809 
813  bool isUltimateMaster() const { return !_multiapp_level; }
814 
818  bool useMasterMesh() const { return _use_master_mesh; }
819 
823  const MooseMesh * masterMesh() const { return _master_mesh; }
824 
829 
834 
839 
849  void addMeshGenerator(const std::string & type,
850  const std::string & name,
851  const InputParameters & params)
852  {
854  }
855 
859  bool hasMeshGenerator(const MeshGeneratorName & name) const
860  {
862  }
863 
867  const MeshGenerator & getMeshGenerator(const std::string & name) const
868  {
870  }
871 
875  std::unique_ptr<MeshBase> getMeshGeneratorMesh()
876  {
878  }
879 
885  std::vector<std::string> getMeshGeneratorNames() const
886  {
888  }
889 
899  const MeshGenerator &
900  appendMeshGenerator(const std::string & type, const std::string & name, InputParameters params)
901  {
903  }
904 
911  virtual bool constructingMeshGenerators() const;
912 
914 
918  void setRestart(bool value);
919  void setRecover(bool value);
921 
923  bool checkInput() const { return _check_input; }
924 
926  bool getFPTrapFlag() const { return _trap_fpe; }
927 
931  bool hasRelationshipManager(const std::string & name) const;
932 
939  bool addRelationshipManager(std::shared_ptr<RelationshipManager> relationship_manager);
940 
942  static const std::string & checkpointSuffix();
944  static std::filesystem::path metaDataFolderBase(const std::filesystem::path & folder_base,
945  const std::string & map_suffix);
947  std::filesystem::path restartFolderBase(const std::filesystem::path & folder_base) const;
948 
956  const hit::Node * getCurrentActionHitNode() const;
957 
964  bool attach_geometric_rm_final = false);
965 
972  void attachRelationshipManagers(MeshBase & mesh, MooseMesh & moose_mesh);
973 
977  const std::vector<std::shared_ptr<RelationshipManager>> & getReleationshipManagers();
978 
982  std::vector<std::pair<std::string, std::string>> getRelationshipManagerInfo() const;
983 
987  const ExecFlagEnum & getExecuteOnEnum() const { return _execute_flags; }
988 
994  bool hasInitialBackup() const
995  {
996  return _initial_backup != nullptr && *_initial_backup != nullptr;
997  }
998 
1003 
1004  // Return the communicator for this application
1005  const std::shared_ptr<libMesh::Parallel::Communicator> getCommunicator() const { return _comm; }
1006 
1010  const std::set<std::shared_ptr<RelationshipManager>> & relationshipManagers() const
1011  {
1012  return _relationship_managers;
1013  }
1014 
1018  void checkMetaDataIntegrity() const;
1019 
1021 
1027 
1030 
1036  virtual bool errorOnJacobianNonzeroReallocation() const { return false; }
1037 
1043  template <class T>
1044  void registerInterfaceObject(T & interface);
1045 
1051  template <class T>
1052  const std::vector<T *> & getInterfaceObjects() const;
1053 
1054  static void addAppParam(InputParameters & params);
1055  static void addInputParam(InputParameters & params);
1056 
1061  bool forceRestart() const { return _force_restart; }
1062 
1065 
1068 
1069 #ifdef MOOSE_MFEM_ENABLED
1070 
1074  void setMFEMDevice(const std::string & device_string, Moose::PassKey<MFEMProblemSolve>);
1075 
1079  std::shared_ptr<mfem::Device> getMFEMDevice(Moose::PassKey<MultiApp>) { return _mfem_device; }
1080 
1084  const std::set<std::string> & getMFEMDevices(Moose::PassKey<MultiApp>) const;
1085 #endif
1086 
1087 protected:
1091  void dynamicRegistration(const libMesh::Parameters & params);
1092 
1097  void loadLibraryAndDependencies(const std::string & library_filename,
1098  const libMesh::Parameters & params,
1099  bool load_dependencies = true);
1100 
1103 
1113  void registerRestartableNameWithFilter(const std::string & name,
1114  Moose::RESTARTABLE_FILTER filter);
1115 
1120  void errorCheck();
1121 
1126  void outputMachineReadableData(const std::string & param,
1127  const std::string & start_marker,
1128  const std::string & end_marker,
1129  const std::string & data) const;
1131  static void addCapability(const std::string & capability,
1132  CapabilityUtils::Type value,
1133  const std::string & doc);
1134  static void
1135  addCapability(const std::string & capability, const char * value, const std::string & doc);
1137 
1139  const std::string _type;
1140 
1142  const std::shared_ptr<libMesh::Parallel::Communicator> _comm;
1143 
1145  std::string _output_file_base;
1146 
1149 
1152 
1155 
1158 
1161 
1164 
1167 
1170  std::unique_ptr<InputParameterWarehouse> _input_parameter_warehouse;
1171 
1174 
1177 
1180 
1182  const std::shared_ptr<Parser> _parser;
1183 
1185  const std::shared_ptr<CommandLine> _command_line;
1186 
1189 
1192 
1194  std::vector<RestartableDataMap> _restartable_data;
1195 
1201 
1204 
1207 
1210 
1212  std::shared_ptr<Executioner> _executioner;
1213 
1215  std::shared_ptr<Executor> _executor;
1216 
1218  std::map<std::string, std::shared_ptr<Executor>> _executors;
1219 
1222  std::unordered_map<std::string, std::pair<std::string, std::unique_ptr<InputParameters>>>
1224 
1228 
1231  const bool _use_executor;
1232 
1234  std::shared_ptr<NullExecutor> _null_executor;
1235 
1238 
1241 
1244  {
1249 
1251 
1255  std::string _early_exit_param;
1259 
1262 
1264  std::shared_ptr<libMesh::ExodusII_IO> _ex_reader;
1265 
1268 
1270  bool _recover;
1271 
1273  bool _restart;
1274 
1277 
1279  const bool _use_split;
1280 
1282  const bool _force_restart;
1283 
1286 
1289 
1293  const bool _test_restep;
1294 
1296  std::map<std::string, unsigned int> _output_file_numbers;
1297 
1300 
1302  std::set<std::shared_ptr<RelationshipManager>> _relationship_managers;
1303 
1305  std::map<Moose::RelationshipManagerType, std::set<const RelationshipManager *>>
1307 
1312  std::unordered_map<RelationshipManager *, std::shared_ptr<libMesh::GhostingFunctor>>
1314 
1316  {
1318  std::string full_path;
1319  std::unordered_set<std::string> entry_symbols;
1320  };
1321 
1323  std::unordered_map<std::string, DynamicLibraryInfo> _lib_handles;
1324 
1325 private:
1334  void recursivelyCreateExecutors(const std::string & current_executor_name,
1335  std::list<std::string> & possible_roots,
1336  std::list<std::string> & current_branch);
1337 
1343  void registerCapabilities();
1344 
1355  void removeRelationshipManager(std::shared_ptr<RelationshipManager> relationship_manager);
1356 
1357 #ifdef MOOSE_LIBTORCH_ENABLED
1358 
1364  torch::DeviceType determineLibtorchDeviceType(const MooseEnum & device) const;
1365 #endif
1366 
1370  {
1372  };
1373 
1374  template <class T>
1376  {
1377  std::vector<T *> _objects;
1378  };
1380 
1405  void createMinimalApp();
1406 
1411  void setCheckUnusedFlag(bool warn_is_error = false);
1412 
1420  bool hasRMClone(const RelationshipManager & template_rm, const MeshBase & mesh) const;
1421 
1426  RelationshipManager & getRMClone(const RelationshipManager & template_rm,
1427  const MeshBase & mesh) const;
1428 
1440  MooseMesh & moose_mesh,
1441  MeshBase & mesh,
1442  const libMesh::DofMap * dof_map = nullptr);
1443 
1451 
1459 
1464  bool showInputs() const;
1465 
1469  virtual std::string getInstallableInputs() const;
1470 
1477  bool copyInputs();
1478 
1484  bool runInputs();
1485 
1490  static void checkReservedCapability(const std::string & capability);
1491 
1493  std::unordered_map<RestartableDataMapName, std::pair<RestartableDataMap, std::string>>
1495 
1498  {
1501  };
1502 
1504  std::unique_ptr<TheWarehouse> _the_warehouse;
1505 
1507  unsigned int _multiapp_level;
1508 
1510  unsigned int _multiapp_number;
1511 
1513  const bool _use_master_mesh;
1514 
1516  const MooseMesh * const _master_mesh;
1517 
1520 
1523 
1526 
1528 
1537 
1539  std::streambuf * _output_buffer_cache;
1540 
1543 
1545  bool _cpu_profiling = false;
1546 
1548  bool _heap_profiling = false;
1549 
1552  std::map<const RelationshipManager *,
1553  std::map<const MeshBase *, std::unique_ptr<RelationshipManager>>>
1555 
1557  std::map<std::type_index, std::unique_ptr<InterfaceRegistryObjectsBase>> _interface_registry;
1558 
1563  std::unique_ptr<Backup> * const _initial_backup;
1564 
1565 #ifdef MOOSE_LIBTORCH_ENABLED
1566  const torch::DeviceType _libtorch_device;
1568 #endif
1569 
1570 #ifdef MOOSE_MFEM_ENABLED
1571  std::shared_ptr<mfem::Device> _mfem_device;
1573 
1575  std::set<std::string> _mfem_devices;
1576 #endif
1577 
1578  // Allow FEProblemBase to set the recover/restart state, so make it a friend
1579  friend class FEProblemBase;
1580  friend class Restartable;
1581  friend class SubProblem;
1582 };
1583 
1584 template <class T>
1585 void
1587 {
1588  static_assert(!std::is_base_of<MooseObject, T>::value, "T is not an interface");
1589 
1590  InterfaceRegistryObjects<T> * registry = nullptr;
1591  auto it = _interface_registry.find(typeid(T));
1592  if (it == _interface_registry.end())
1593  {
1594  auto new_registry = std::make_unique<InterfaceRegistryObjects<T>>();
1595  registry = new_registry.get();
1596  _interface_registry.emplace(typeid(T), std::move(new_registry));
1597  }
1598  else
1599  registry = static_cast<InterfaceRegistryObjects<T> *>(it->second.get());
1600 
1601  mooseAssert(std::count(registry->_objects.begin(), registry->_objects.end(), &interface) == 0,
1602  "Interface already registered");
1603  registry->_objects.push_back(&interface);
1604 }
1605 
1606 template <class T>
1607 const std::vector<T *> &
1609 {
1610  static_assert(!std::is_base_of<MooseObject, T>::value, "T is not an interface");
1611 
1612  const auto it = _interface_registry.find(typeid(T));
1613  if (it != _interface_registry.end())
1614  return static_cast<InterfaceRegistryObjects<T> *>(it->second.get())->_objects;
1615  const static std::vector<T *> empty;
1616  return empty;
1617 }
1618 
1619 #ifdef MOOSE_MFEM_ENABLED
1620 inline const std::set<std::string> &
1622 {
1623  return _mfem_devices;
1624 }
1625 #endif
std::list< std::string > getCheckpointFiles() const
Extract all possible checkpoint file names.
Definition: MooseApp.C:2422
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3527
std::list< std::string > getCheckpointDirectories() const
Get all checkpoint directories.
Definition: MooseApp.C:2390
bool _use_eigen_value
Boolean to indicate whether to use an eigenvalue executioner.
Definition: MooseApp.h:1240
static const std::string & checkpointSuffix()
The file suffix for the checkpoint mesh.
Definition: MooseApp.C:3072
std::string getFileName(bool stripLeadingPath=true) const
Return the primary (first) filename that was parsed Note: When stripLeadingPath is false...
Definition: MooseApp.C:2436
void addExecutorParams(const std::string &type, const std::string &name, const InputParameters &params)
Adds the parameters for an Executor to the list of parameters.
Definition: MooseApp.C:1979
bool defaultAutomaticScaling() const
Whether to enable automatic scaling by default.
Definition: MooseApp.h:1002
bool & useNonlinear()
Returns a writable Boolean indicating whether this app will use a Nonlinear or Eigen System...
Definition: MooseApp.h:384
virtual std::string getPrintableName() const
Get printable name of the application.
Definition: MooseApp.h:135
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
Definition: MooseApp.h:1507
virtual std::string getInstallableInputs() const
Method to retrieve the installable inputs from a given applications <app>Revision.h file.
Definition: MooseApp.C:2238
PerfGraph & _perf_graph
The PerfGraph object for this application (recoverable)
Definition: MooseApp.h:1203
const std::set< std::string > & getMFEMDevices(Moose::PassKey< MultiApp >) const
Get the configured MFEM devices.
Definition: MooseApp.h:1621
void setOutputPosition(const Point &p)
Tell the app to output in a specific position.
Definition: MooseApp.C:2379
bool hasMeshGenerator(const MeshGeneratorName &name) const
Definition: MooseApp.h:859
std::vector< std::string > sub_transformed_vars
The names of variables to transform for fixed point solve algorithms (e.g. secant, etc.).
Definition: MooseApp.h:118
const std::string _type
The string representation of the type of this object as registered (see registerApp(AppName)) ...
Definition: MooseApp.h:1139
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
void setExecutioner(std::shared_ptr< Executioner > &&executioner)
Set the Executioner for this App.
Definition: MooseApp.h:336
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:1223
A class for creating restricted objects.
Definition: Restartable.h:28
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:813
bool _initial_from_file
This variable indicates when a request has been made to restart from an Exodus file.
Definition: MooseApp.h:1261
Stores configuration options relating to the fixed-point solving capability.
Definition: MooseApp.h:112
Storage container for all InputParamter objects.
const MeshGenerator & getMeshGenerator(const std::string &name) const
Definition: MooseApp.h:867
std::map< Moose::RelationshipManagerType, std::set< const RelationshipManager * > > _attached_relationship_managers
The relationship managers that have been attached (type -> RMs)
Definition: MooseApp.h:1306
auto getRestartableDataMapBegin()
Iterator based access to the extra RestartableDataMap objects; see Checkpoint.C for use case...
Definition: MooseApp.h:1026
Reader for restartable data written by the RestartableDataWriter.
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:1288
void dynamicRegistration(const libMesh::Parameters &params)
Helper method for dynamic loading of objects.
Definition: MooseApp.C:2700
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
Definition: MooseApp.C:2534
std::vector< PostprocessorName > sub_transformed_pps
The names of postprocessors to transform for fixed point solve algorithms (e.g. secant, etc.).
Definition: MooseApp.h:120
virtual void setupOptions()
Setup options based on InputParameters.
Definition: MooseApp.C:1235
PerfGraph & createRecoverablePerfGraph()
Creates a recoverable PerfGraph.
Definition: MooseApp.C:3496
std::string libNameToAppName(const std::string &library_name) const
Converts a library name to an application name:
Definition: MooseApp.C:2470
RelationshipManagerType
Main types of Relationship Managers.
Definition: MooseTypes.h:964
void registerCapabilities()
Register all base MooseApp capabilities to the Moose::Capabilities registry.
const std::shared_ptr< Parser > _parser
Parser for parsing the input file (owns the root hit node)
Definition: MooseApp.h:1182
std::string getFrameworkVersion() const
Returns the framework version.
Definition: MooseApp.C:1217
Base class for everything in MOOSE with a name and a type.
Definition: MooseBase.h:49
void setRecover(bool value)
Definition: MooseApp.C:2918
std::vector< std::pair< std::string, std::string > > getRelationshipManagerInfo() const
Returns the Relationship managers info suitable for printing.
Definition: MooseApp.C:3352
void setExecutor(std::shared_ptr< Executor > &&executor)
Definition: MooseApp.h:337
Real _global_time_offset
Offset of the local App time to the "global" problem time.
Definition: MooseApp.h:1163
bool hasOutputPosition() const
Whether or not an output position has been set.
Definition: MooseApp.h:269
bool hasRMClone(const RelationshipManager &template_rm, const MeshBase &mesh) const
Definition: MooseApp.C:3103
torch::DeviceType determineLibtorchDeviceType(const MooseEnum &device) const
Function to determine the device which should be used by libtorch on this application.
Definition: MooseApp.C:3535
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
Definition: MooseApp.h:1148
const std::vector< RestartableDataMap > & getRestartableData() const
Return reference to the restartable data object.
Definition: MooseApp.h:680
bool _output_position_set
Whether or not an output position has been set for this app.
Definition: MooseApp.h:1151
Generic factory class for build all sorts of objects.
Definition: Factory.h:28
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 num...
Definition: MooseApp.h:539
std::unique_ptr< TheWarehouse > _the_warehouse
The combined warehouse for storing any MooseObject based object.
Definition: MooseApp.h:1504
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:1948
std::shared_ptr< CommandLine > commandLine() const
Get the command line.
Definition: MooseApp.h:411
std::vector< std::string > getMeshGeneratorNames() const
Definition: MooseApp.h:885
bool hasInitialBackup() const
Definition: MooseApp.h:994
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:3079
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2900
const ExecFlagEnum & getExecuteOnEnum() const
Return the app level ExecFlagEnum, this contains all the available flags for the app.
Definition: MooseApp.h:987
bool _use_nonlinear
Boolean to indicate whether to use a Nonlinear or EigenSystem (inspected by actions) ...
Definition: MooseApp.h:1237
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:123
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:1494
FixedPointConfig & fixedPointConfig()
This info is stored here because we need a "globalish" place to put it in order to allow communicatio...
Definition: MooseApp.h:379
virtual std::string appBinaryName() const
Definition: MooseApp.h:137
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:127
std::string getOutputFileBase(bool for_non_moose_build_output=false) const
Get the output file base name.
Definition: MooseApp.C:1669
const bool _use_master_mesh
Whether to use the parent app mesh for this app.
Definition: MooseApp.h:1513
static void addInputParam(InputParameters &params)
Definition: MooseApp.C:102
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:3111
bool runInputs()
Handles the run input parameter logic: Checks to see whether a directory exists in user space and lau...
Definition: MooseApp.C:2309
void registerRestartableNameWithFilter(const std::string &name, Moose::RESTARTABLE_FILTER filter)
NOTE: This is an internal function meant for MOOSE use only!
Definition: MooseApp.C:1833
virtual void run()
Run the application.
Definition: MooseApp.C:2135
void removeRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Purge this relationship manager from meshes and DofMaps and finally from us.
Definition: MooseApp.C:3126
std::unique_ptr< libMesh::MeshBase > getSavedMesh(const std::string &name)
Get the saved mesh by name.
Real _start_time
The time at which to start the simulation.
Definition: MooseApp.h:1160
void createExecutors()
After adding all of the Executor Params - this function will actually cause all of them to be built...
Definition: MooseApp.C:2052
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:2000
Builds lists and maps that help in knowing which physical hardware nodes each rank is on...
Definition: RankMap.h:23
std::vector< std::string > getMeshGeneratorNames() const
Get names of all mesh generators Note: This function should be called after all mesh generators are a...
bool forceRestart() const
Whether or not we are forcefully restarting (allowing the load of potentially incompatibie checkpoint...
Definition: MooseApp.h:1061
std::filesystem::path restartFolderBase(const std::filesystem::path &folder_base) const
The file suffix for restartable data.
Definition: MooseApp.C:3087
const bool _use_split
Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)
Definition: MooseApp.h:1279
unsigned int multiAppLevel() const
The MultiApp Level.
Definition: MooseApp.h:802
bool hasRelationshipManager(const std::string &name) const
Returns a Boolean indicating whether a RelationshipManater exists with the same name.
Definition: MooseApp.C:2998
Base class for MOOSE-based applications.
Definition: MooseApp.h:96
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:1299
const std::vector< std::shared_ptr< RelationshipManager > > & getReleationshipManagers()
Retrieve the relationship managers.
bool hasRestartableDataMap(const RestartableDataMapName &name) const
Definition: MooseApp.C:3471
std::set< std::string > _mfem_devices
MFEM supported devices based on user-provided config.
Definition: MooseApp.h:1575
Syntax _syntax
Syntax of the input file.
Definition: MooseApp.h:1166
Syntax & syntax()
Returns a writable reference to the syntax object.
Definition: MooseApp.h:218
std::map< std::string, std::shared_ptr< Executor > > _executors
Pointers to all of the Executors for this run.
Definition: MooseApp.h:1218
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:2585
const bool _test_restep
Whether or not this simulation should fail its middle timestep and repeat (for testing) ...
Definition: MooseApp.h:1293
bool _trap_fpe
Whether or not FPE trapping should be turned on.
Definition: MooseApp.h:1285
int exitCode() const
Get the shell exit code for the application.
Definition: MooseApp.h:150
processor_id_type processor_id() const
Returns the MPI processor ID of the current processor.
Definition: MooseApp.h:404
Real getStartTime() const
Definition: MooseApp.h:293
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
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:1296
const hit::Node * getCurrentActionHitNode() const
Definition: MooseApp.C:3095
ActionWarehouse _action_warehouse
Where built actions are stored.
Definition: MooseApp.h:1176
RestartableDataReader _rd_reader
Definition: MooseApp.h:1527
void checkMetaDataIntegrity() const
Function to check the integrity of the restartable meta data structure.
Definition: MooseApp.C:3428
static InputParameters validParams()
Definition: MooseApp.C:109
bool isRestarting() const
Whether or not this is a "restart" calculation.
Definition: MooseApp.C:1807
unsigned int multiAppNumber() const
The MultiApp number.
Definition: MooseApp.h:808
bool isSplitMesh() const
Whether or not this is a split mesh operation.
Definition: MooseApp.C:1813
RestartableDataMap & getRestartableDataMap(const RestartableDataMapName &name)
Return a reference to restartable data for the specific type flag.
Definition: MooseApp.C:3460
ActionFactory & getActionFactory()
Retrieve a writable reference to the ActionFactory associated with this App.
Definition: MooseApp.h:399
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
SolutionInvalidity & _solution_invalidity
The SolutionInvalidity object for this application.
Definition: MooseApp.h:1206
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 GhostingFun...
Definition: MooseApp.h:1313
std::shared_ptr< libMesh::ExodusII_IO > _ex_reader
The Exodus reader when _initial_from_file is set to true.
Definition: MooseApp.h:1264
FEProblemBase & feProblem() const
Definition: MooseApp.C:1960
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:394
MooseApp(const InputParameters &parameters)
Constructor is protected so that this object is constructed through the AppFactory object...
Definition: MooseApp.C:439
std::optional< MooseEnum > getComputeDevice() const
Get the device accelerated computations are supposed to be running on.
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
Definition: MooseApp.h:1194
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:3168
void setOutputFileBase(const std::string &output_file_base)
Override the selection of the output file base name.
Definition: MooseApp.C:1678
std::string getRecoverFileBase() const
Definition: MooseApp.h:488
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:1209
This class wraps provides and tracks access to command line parameters.
Definition: CommandLine.h:29
const bool _test_checkpoint_half_transient
Whether or not this simulation should only run half its transient (useful for testing recovery) ...
Definition: MooseApp.h:1291
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.
int _exit_code
The exit code.
Definition: MooseApp.h:1258
SystemInfo _sys_info
System Information.
Definition: MooseApp.h:1188
Storage for restartable data that is ordered based on insertion order.
bool checkInput() const
Returns whether the Application is running in check input mode.
Definition: MooseApp.h:923
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.
bool getExodusFileRestart() const
Whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh...
Definition: MooseApp.h:423
const RankMap & rankMap()
The RankMap is a useful object for determining how the processes are laid out on the physical nodes o...
Definition: MooseApp.h:161
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
Definition: MooseApp.h:1522
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 sup...
Definition: MooseApp.C:3237
uint8_t processor_id_type
bool getDistributedMeshOnCommandLine() const
Returns true if the user specified –distributed-mesh (or –parallel-mesh, for backwards compatibilit...
Definition: MooseApp.h:453
bool _start_time_set
Whether or not an start time has been set.
Definition: MooseApp.h:1157
void setRestartRecoverFileBase(const std::string &file_base)
mutator for recover_base (set by RecoverBaseAction)
Definition: MooseApp.h:499
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:2563
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:99
bool showInputs() const
Prints a message showing the installable inputs for a given application (if getInstallableInputs has ...
Definition: MooseApp.C:2206
bool addRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Transfers ownership of a RelationshipManager to the application for lifetime management.
Definition: MooseApp.C:3024
RestartableDataValue & getRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname, THREAD_ID tid)
Definition: MooseApp.C:2544
std::vector< RestartableDataMap > & getRestartableData()
Definition: MooseApp.h:681
std::shared_ptr< NullExecutor > _null_executor
Used to return an executor that does nothing.
Definition: MooseApp.h:1234
bool & useEigenvalue()
Returns a writable Boolean indicating whether this app will use an eigenvalue executioner.
Definition: MooseApp.h:389
const std::string & getLastInputFileName() const
Definition: MooseApp.C:1662
virtual void preBackup()
Insertion point for other apps that is called before backup()
Definition: MooseApp.h:732
void setErrorOverridden()
Set a flag so that the parser will throw an error if overridden parameters are detected.
Definition: MooseApp.C:2129
const std::set< std::shared_ptr< RelationshipManager > > & relationshipManagers() const
Return the container of relationship managers.
Definition: MooseApp.h:1010
virtual void postRestore(const bool)
Insertion point for other apps that is called after restore()
Definition: MooseApp.h:766
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:2713
bool _restart
Whether or not this is a restart run.
Definition: MooseApp.h:1273
std::unique_ptr< Backup > backup()
Backs up the application memory in a Backup.
Definition: MooseApp.C:1859
RESTARTABLE_FILTER
The filter type applied to a particular piece of "restartable" data.
Definition: MooseTypes.h:792
Moose::Builder & builder()
Returns a writable reference to the builder.
Definition: MooseApp.h:213
bool unusedFlagIsError() const
Returns whether the flag for unused parameters is set to throw an error.
Definition: MooseApp.h:1067
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:310
std::string getLatestCheckpointFilePrefix(const std::list< std::string > &checkpoint_files)
Returns the most recent checkpoint prefix (the four numbers at the beginning) If a suitable file isn&#39;...
Definition: MooseUtils.C:815
void setExodusFileRestart(bool flag)
Set the flag to indicate whether or not we need to use a separate Exodus reader to read the mesh BEFO...
Definition: MooseApp.h:417
std::map< std::type_index, std::unique_ptr< InterfaceRegistryObjectsBase > > _interface_registry
Registration for interface objects.
Definition: MooseApp.h:1557
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition: MooseApp.h:172
RestartableDataValue & registerRestartableData(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
Definition: MooseApp.C:2482
std::unique_ptr< MeshBase > getMeshGeneratorMesh()
Definition: MooseApp.h:875
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:50
void setRestart(bool value)
Sets the restart/recover flags.
Definition: MooseApp.C:2912
TheWarehouse is a container for MooseObjects that allows querying/filtering over various customizeabl...
Definition: TheWarehouse.h:185
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
Definition: MooseApp.h:1212
torch::DeviceType getLibtorchDevice() const
Get the device torch is supposed to be running on.
Definition: MooseApp.h:104
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 num...
Definition: MooseApp.h:527
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:88
ActionFactory _action_factory
The Factory responsible for building Actions.
Definition: MooseApp.h:1173
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:89
void restoreFromInitialBackup(const bool for_restart)
Restores from a "initial" backup, that is, one set in _initial_backup.
Definition: MooseApp.C:1909
const ActionWarehouse & actionWarehouse() const
Return a const reference to the ActionWarehouse associated with this app.
Definition: MooseApp.h:208
const Parser & parser() const
Definition: MooseApp.C:1987
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
ActionWarehouse & actionWarehouse()
Return a writable reference to the ActionWarehouse associated with this app.
Definition: MooseApp.h:204
RegistrationType
Enumeration for holding the valid types of dynamic registrations allowed.
Definition: MooseApp.h:1497
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:30
enum MooseApp::UNUSED_CHECK _enable_unused_check
bool _recover
Whether or not this is a recovery run.
Definition: MooseApp.h:1270
Point _output_position
The output position.
Definition: MooseApp.h:1154
const MooseMesh * masterMesh() const
Returns a pointer to the master mesh.
Definition: MooseApp.h:823
bool testReStep() const
Whether or not this simulation should fail a timestep and repeat (for testing).
Definition: MooseApp.h:517
bool testCheckpointHalfTransient() const
Whether or not this simulation should only run half its transient (useful for testing recovery) ...
Definition: MooseApp.h:511
const std::shared_ptr< CommandLine > _command_line
The CommandLine object.
Definition: MooseApp.h:1185
libMesh::ExodusII_IO * getExReaderForRestart() const
Get the Exodus reader to restart variables from an Exodus mesh file.
Definition: MooseApp.h:436
bool _error_overridden
Indicates whether warnings or errors are displayed when overridden parameters are detected...
Definition: MooseApp.h:1253
virtual std::string getVersion() const
Returns the current version of the framework or application (default: framework version).
Definition: MooseApp.C:1223
SolutionInvalidity & createRecoverableSolutionInvalidity()
Creates a recoverable SolutionInvalidity.
Definition: MooseApp.C:3514
bool _heap_profiling
Memory profiling.
Definition: MooseApp.h:1548
const MooseMesh *const _master_displaced_mesh
The displaced mesh from master app.
Definition: MooseApp.h:1519
Class for storing and utilizing output objects.
Interface for objects interacting with the PerfGraph.
const bool _force_restart
Whether or not we are forcefully attempting to load checkpoints (–force-restart) ...
Definition: MooseApp.h:1282
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
Definition: MooseApp.C:2123
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:2874
void setGlobalTimeOffset(Real offset)
Each App has it&#39;s own local time.
Definition: MooseApp.h:299
The SolutionInvalidity will contain all the information about the occurrence(s) of solution invalidit...
std::unordered_map< std::string, DynamicLibraryInfo > _lib_handles
The library archive (name only), registration method and the handle to the method.
Definition: MooseApp.h:1323
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:3568
Point getOutputPosition() const
Get the output position.
Definition: MooseApp.h:275
Definition: Moose.h:42
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.
Definition: MooseApp.h:900
static std::string mainMeshGeneratorName()
The name reserved for the "main" mesh generator which is the one used for the numerical solver downst...
const std::string & getRestartableDataMapName(const RestartableDataMapName &name) const
Definition: MooseApp.C:3487
FixedPointConfig _fixed_point_config
Multiapp-related fixed point algorithm configuration details primarily intended to be passed to and u...
Definition: MooseApp.h:1227
const ExecFlagEnum _execute_flags
Execution flags for this App.
Definition: MooseApp.h:1536
UNUSED_CHECK
Indicates whether warnings, errors, or no output is displayed when unused parameters are detected...
Definition: MooseApp.h:1243
bool hasRecoverFileBase() const
Definition: MooseApp.C:1825
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:1554
const MooseMesh * masterDisplacedMesh() const
Returns a pointer to the master displaced mesh.
Definition: MooseApp.h:828
bool hasRestartRecoverFileBase() const
Return true if the recovery file base is set.
Definition: MooseApp.C:1819
void registerRestartableDataMapName(const RestartableDataMapName &name, std::string suffix="")
Reserve a location for storing custom RestartableDataMap objects.
Definition: MooseApp.C:3477
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:2366
void restore(const std::filesystem::path &folder_base, const bool for_restart)
Restore an application from file.
Definition: MooseApp.C:1874
void loadRestartableMetaData(const std::filesystem::path &folder_base)
Loads all available restartable meta data if it is available with the folder base folder_base...
Definition: MooseApp.C:2578
ChainControlDataSystem _chain_control_system
The system that manages the ChainControls.
Definition: MooseApp.h:1525
const SystemInfo & getSystemInfo() const
Get SystemInfo object.
Definition: MooseApp.h:554
virtual void executeExecutioner()
Execute the Executioner that was built.
Definition: MooseApp.C:1769
Real sub_relaxation_factor
relaxation factor to be used for a MultiApp&#39;s subapps.
Definition: MooseApp.h:116
bool _distributed_mesh_on_command_line
This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh...
Definition: MooseApp.h:1267
void addExecutor(const std::string &type, const std::string &name, const InputParameters &params)
Definition: MooseApp.C:1967
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
NullExecutor * getNullExecutor() const
Definition: MooseApp.h:329
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
bool getFPTrapFlag() const
Returns whether FPE trapping is turned on (either because of debug or user requested) ...
Definition: MooseApp.h:926
Moose::Builder _builder
Builder for building app related parser tree.
Definition: MooseApp.h:1191
const torch::DeviceType _libtorch_device
The libtorch device this app is using (converted from compute_device)
Definition: MooseApp.h:1567
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: MooseApp.h:849
std::string RestartableDataMapName
Definition: MooseTypes.h:214
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
Definition: MooseApp.h:1302
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
Definition: MooseApp.h:1179
std::string _output_file_base
The output file basename.
Definition: MooseApp.h:1145
std::streambuf * _output_buffer_cache
Cache output buffer so the language server can turn it off then back on.
Definition: MooseApp.h:1539
static void addAppParam(InputParameters &params)
Definition: MooseApp.C:95
bool _cpu_profiling
CPU profiling.
Definition: MooseApp.h:1545
bool unusedFlagIsWarning() const
Returns whether the flag for unused parameters is set to throw a warning only.
Definition: MooseApp.h:1064
auto getRestartableDataMapEnd()
Definition: MooseApp.h:1028
virtual void runInputFile()
Actually build everything in the input file.
Definition: MooseApp.C:1694
bool hasStartTime() const
Definition: MooseApp.h:288
System that manages ChainControls.
std::variant< bool, int, std::string > Type
A capability can have a bool, int, or string value.
virtual std::string header() const
Returns a string to be printed at the beginning of a simulation.
Definition: MooseApp.C:2906
const SolutionInvalidity & solutionInvalidity() const
Definition: MooseApp.h:173
Holding syntax for parsing input files.
Definition: Syntax.h:21
bool useMasterMesh() const
Returns whether to use the parent app mesh as the mesh for this app.
Definition: MooseApp.h:818
std::unordered_set< std::string > DataNames
static const std::string MESH_META_DATA_SUFFIX
Definition: MooseApp.h:124
const bool _automatic_automatic_scaling
Whether to turn on automatic scaling by default.
Definition: MooseApp.h:1542
Factory _factory
Definition: MooseApp.h:1250
ChainControlDataSystem & getChainControlDataSystem()
Gets the system that manages the ChainControls.
Definition: MooseApp.h:838
std::unique_ptr< InputParameterWarehouse > _input_parameter_warehouse
Input parameter storage structure; unique_ptr so we can control its destruction order.
Definition: MooseApp.h:1170
bool hasMeshGenerator(const MeshGeneratorName &name) const
const std::vector< std::string > & getInputFileNames() const
Definition: MooseApp.C:1655
void setMFEMDevice(const std::string &device_string, Moose::PassKey< MFEMProblemSolve >)
Create/configure the MFEM device with the provided device_string.
Definition: MooseApp.C:3612
static void addCapability(const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
register a new capability
Definition: MooseApp.C:3595
const std::vector< T * > & getInterfaceObjects() const
Gets the registered interface objects for a given interface.
Definition: MooseApp.h:1608
TheWarehouse & theWarehouse()
Definition: MooseApp.h:130
const MeshGenerator & getMeshGenerator(const std::string &name) const
std::unique_ptr< Backup > finalizeRestore()
Finalizes (closes) the restoration process done in restore().
Definition: MooseApp.C:1916
System that manages MeshGenerators.
unsigned int _multiapp_number
Numbering in all the sub-apps on the same level.
Definition: MooseApp.h:1510
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.
Definition: MooseApp.C:2671
MeshGeneratorSystem & getMeshGeneratorSystem()
Gets the system that manages the MeshGenerators.
Definition: MooseApp.h:833
const DataNames & getRecoverableData() const
Return a reference to the recoverable data object.
Definition: MooseApp.h:714
std::unordered_set< std::string > entry_symbols
Definition: MooseApp.h:1319
Parses MOOSE input using HIT/WASP.
Definition: Builder.h:56
const std::shared_ptr< libMesh::Parallel::Communicator > _comm
The MPI communicator this App is going to use.
Definition: MooseApp.h:1142
std::string getPrintableVersion() const
Non-virtual method for printing out the version string in a consistent format.
Definition: MooseApp.C:1229
std::shared_ptr< mfem::Device > _mfem_device
The MFEM Device object.
Definition: MooseApp.h:1572
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112
void createMinimalApp()
Method for creating the minimum required actions for an application (no input file) ...
Definition: MooseApp.C:2924
void setExitCode(const int exit_code)
Sets the exit code that the application will exit with.
Definition: MooseApp.h:155
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:1801
DataNames _recoverable_data_names
Data names that will only be read from the restart file during RECOVERY.
Definition: MooseApp.h:1200
Executor * getExecutor() const
Definition: MooseApp.h:328
bool _ready_to_exit
Definition: MooseApp.h:1256
The PerfGraph will hold the master list of all registered performance segments and the head PerfNode...
Definition: PerfGraph.h:43
bool copyInputs()
Handles the copy_inputs input parameter logic: Checks to see whether the passed argument is valid (a ...
Definition: MooseApp.C:2244
virtual bool errorOnJacobianNonzeroReallocation() const
Whether this application should by default error on Jacobian nonzero reallocations.
Definition: MooseApp.h:1036
Real getGlobalTimeOffset() const
Each App has it&#39;s own local time.
Definition: MooseApp.h:305
std::shared_ptr< mfem::Device > getMFEMDevice(Moose::PassKey< MultiApp >)
Get the MFEM device object.
Definition: MooseApp.h:1079
std::string getRestartRecoverFileBase() const
The file_base for the recovery file.
Definition: MooseApp.h:487
const MooseMesh *const _master_mesh
The mesh from master app.
Definition: MooseApp.h:1516
const std::shared_ptr< libMesh::Parallel::Communicator > getCommunicator() const
Definition: MooseApp.h:1005
MeshGenerators are objects that can modify or add to an existing mesh.
Definition: MeshGenerator.h:32
void disableCheckUnusedFlag()
Removes warnings and error checks for unrecognized variables in the input file.
Definition: MooseApp.C:1954
bool useExecutor() const
Definition: MooseApp.h:330
bool _split_mesh
Whether or not we are performing a split mesh operation (–split-mesh)
Definition: MooseApp.h:1276
const bool _use_executor
Indicates whether we are operating in the new/experimental executor mode instead of using the legacy ...
Definition: MooseApp.h:1231
Abstract definition of a RestartableData value.
PerfGraph & perfGraph()
Get the PerfGraph for this app.
Definition: MooseApp.h:166
Class for parsing input files.
Definition: Parser.h:87
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2442
std::string getExecutableName()
Gets the name of the running executable on Mac OS X and linux.
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:2454
void registerInterfaceObject(T &interface)
Registers an interface object for accessing with getInterfaceObjects.
Definition: MooseApp.h:1586
virtual ~MooseApp()
Definition: MooseApp.C:1180
void setExReaderForRestart(std::shared_ptr< libMesh::ExodusII_IO > &&exreader)
Set the Exodus reader to restart variables from an Exodus mesh file.
Definition: MooseApp.h:428
unsigned int THREAD_ID
Definition: MooseTypes.h:209
void setStartTime(Real time)
Set the starting time for the simulation.
Definition: MooseApp.C:2429
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
Definition: MooseApp.h:1215
The Executor class directs the execution flow of simulations.
Definition: Executor.h:26
void errorCheck()
Runs post-initialization error checking that cannot be run correctly unless the simulation has been f...
Definition: MooseApp.C:1733
std::set< std::string > getLoadedLibraryPaths() const
Return the paths of loaded libraries.
Definition: MooseApp.C:2863
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:1255
void dynamicAppRegistration(const std::string &app_name, std::string library_path, const std::string &library_name, bool lib_load_deps)
Definition: MooseApp.C:2614
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:1563