10 #ifdef HAVE_GPERFTOOLS 11 #include "gperftools/profiler.h" 12 #include "gperftools/heap-profiler.h" 16 #include "MooseRevision.h" 62 #include "libmesh/exodusII_io.h" 63 #include "libmesh/mesh_refinement.h" 64 #include "libmesh/string_to_enum.h" 65 #include "libmesh/checkpoint_io.h" 66 #include "libmesh/mesh_base.h" 67 #include "libmesh/petsc_solver_exception.h" 70 #ifdef LIBMESH_HAVE_DLOPEN 72 #include <sys/utsname.h> 75 #ifdef MOOSE_LIBTORCH_ENABLED 76 #include <torch/version.h> 82 #include <sys/types.h> 91 #define QUOTE(macro) stringifyName(macro) 97 "app_to_run",
"--app <type>",
"Specify the application type to run (case-sensitive)");
104 "input_file",
"-i <input file(s)>",
"Specify input file(s); multiple files are merged");
115 params.
addCommandLineParam<
bool>(
"display_version",
"-v --version",
"Print application version");
119 "--mesh-only <optional path>",
121 "Build and output the mesh only (Default: \"<input_file_name>_in.e\")");
124 "show_input",
"--show-input",
"Shows the parsed input file before running the simulation");
127 "show_outputs",
"--show-outputs",
"Shows the output execution time information");
130 "show_controls",
"--show-controls",
"Shows the Control logic available and executed");
134 "no_color",
"--no-color",
"Disable coloring of all Console outputs");
139 "color",
"--color <auto,on,off=on>", colors,
"Whether to use color in console output");
146 "Ignore input file and build a minimal application with Transient executioner");
151 "Starts a process to communicate with development tools using the language server protocol");
154 "definition",
"--definition",
"Shows a SON style input definition dump for input validation");
155 params.
addCommandLineParam<
bool>(
"dump",
"--dump",
"Shows a dump of available input file syntax");
158 "--dump-search <search>",
159 "Shows a dump of available input syntax matching a search");
160 params.
addCommandLineParam<
bool>(
"registry",
"--registry",
"Lists all known objects and actions");
162 "registry_hit",
"--registry-hit",
"Lists all known objects and actions in hit format");
164 "use_executor",
"--executor",
"Use the new Executor system instead of Executioners");
167 "show_type",
"--show-type",
"Return the name of the application object");
168 params.
addCommandLineParam<
bool>(
"yaml",
"--yaml",
"Dumps all input file syntax in YAML format");
170 "yaml_search",
"--yaml-search",
"Dumps input file syntax matching a search in YAML format");
171 params.
addCommandLineParam<
bool>(
"json",
"--json",
"Dumps all input file syntax in JSON format");
173 "json_search",
"--json-search",
"Dumps input file syntax matching a search in JSON format");
175 "syntax",
"--syntax",
"Dumps the associated Action syntax paths ONLY");
177 "show_docs",
"--docs",
"Print url/path to the documentation website");
179 "show_capabilities",
"--show-capabilities",
"Dumps the capability registry in JSON format.");
181 "required_capabilities",
182 "--required-capabilities",
183 "A list of conditions that is checked against the registered capabilities (see " 184 "--show-capabilities). The executable will terminate early if the conditions are not met.");
186 "check_capabilities",
187 "--check-capabilities",
188 "A list of conditions that is checked against the registered capabilities. Will exit based " 189 "on whether or not the capaiblities are fulfilled. Does not check dynamically loaded apps.");
192 "Check the input file (i.e. requires -i <filename>) and quit");
196 "--show-copyable-inputs",
197 "Shows the directories able to be copied into a user-writable location");
201 "--copy-inputs <dir>",
202 "Copies installed inputs (e.g. tests, examples, etc.) to a directory <appname>_<dir>");
207 "--run <test harness args>",
209 "Runs the inputs in the current directory copied to a " 210 "user-writable location by \"--copy-inputs\"");
213 "list_constructed_objects",
214 "--list-constructed-objects",
215 "List all moose object type names constructed by the master app factory");
218 "n_threads",
"--n-threads=<n>",
"Runs the specified number of threads per process");
225 "Warn about unused input file options instead of erroring");
228 "error_unused",
"-e --error-unused",
"Error when encountering unused input file options");
232 "-o --error-override",
233 "Error when encountering overridden or parameters supplied multiple times");
236 "error_deprecated",
"--error-deprecated",
"Turn deprecated code messages into Errors");
240 "--distributed-mesh",
241 "Forces the use of a distributed finite element mesh");
248 "--split-mesh <splits>",
249 "Comma-separated list of numbers of chunks to split the mesh into");
253 "split_file",
"--split-file <filename>",
"Name of split mesh file(s) to write/read");
255 params.
addCommandLineParam<
bool>(
"use_split",
"--use-split",
"Use split distributed mesh files");
258 "refinements",
"-r <num refinements>",
"Specify additional initial uniform mesh refinements");
262 "--recover <optional file base>",
264 "Continue the calculation. Without <file base>, the most recent recovery file will be used");
269 "Forcefully load checkpoints despite possible incompatibilities");
275 "Disables the output of the application header.");
279 "test_checkpoint_half_transient",
280 "--test-checkpoint-half-transient",
281 "Run half of a transient with checkpoints enabled; used by the TestHarness");
286 "Test re-running the middle timestep; used by the TestHarness");
291 "Enable floating point exception handling in critical sections of code" 293 " (automatic due to debug build)" 301 "Disable floating point exception handling in critical sections of code" 303 " (unused due to non-debug build)" 310 "no_gdb_backtrace",
"--no-gdb-backtrace",
"Disables gdb backtraces.");
318 "Enable all performance logging for timing; disables screen " 319 "output of performance logs for all Console objects");
322 "no_timing",
"--no-timing",
"Disabled performance logging; overrides -t or --timing");
326 "allow_test_objects",
"--allow-test-objects",
"Register test objects and syntax");
334 "Keep standard output from all processors when running in parallel");
339 "Keep standard output from all processors when running in parallel");
344 "--timpi-sync <type=nbx>",
346 "Changes the sync type used in spare parallel communitations within TIMPI");
351 "--start-in-debugger <debugger>",
352 "Start the application and attach a debugger; this will " 353 "launch xterm windows using <debugger>");
357 "--stop-for-debugger <seconds>",
358 "Pauses the application during startup for <seconds> to allow for connection of debuggers");
361 "perf_graph_live_all",
"--perf-graph-live-all",
"Forces printing of ALL progress messages");
365 "disable_perf_graph_live",
"--disable-perf-graph-live",
"Disables PerfGraph live printing");
369 "automatic_automatic_scaling",
false,
"Whether to turn on automatic scaling by default");
371 MooseEnum libtorch_device_type(
"cpu cuda mps",
"cpu");
374 libtorch_device_type,
375 "The device type we want to run libtorch on.");
377 #ifdef HAVE_GPERFTOOLS 380 "--gperf-profiler-on <ranks>",
381 "To generate profiling report only on comma-separated list of MPI ranks");
386 "--show-data-params",
388 "Show found paths for all DataFileName parameters in the header");
392 "Show registered data paths for searching in the header");
399 params.
addPrivateParam<std::shared_ptr<Parallel::Communicator>>(
"_comm");
405 params.
addPrivateParam<std::unique_ptr<Backup> *>(
"_initial_backup",
nullptr);
407 #ifdef MOOSE_MFEM_ENABLED 413 "use_legacy_material_output",
415 "Set false to allow material properties to be output on INITIAL, not just TIMESTEP_END.");
417 "use_legacy_initial_residual_evaluation_behavior",
419 "The legacy behavior performs an often times redundant residual evaluation before the " 420 "solution modifying objects are executed prior to the initial (0th nonlinear iteration) " 421 "residual evaluation. The new behavior skips that redundant residual evaluation unless the " 422 "parameter Executioner/use_pre_SMO_residual is set to true.");
427 "Set true to enable data-driven mesh generation, which is an experimental feature");
431 "--parse-neml2-only",
432 "Executes the [NEML2] block to parse the input file and terminate.");
451 AppFactory::instance().getAppParams(parameters).
get<
std::string>(
"_app_name"),
453 AppFactory::instance().getAppParams(parameters)),
454 _pars(
AppFactory::instance().getAppParams(parameters)),
455 _comm(getParam<
std::shared_ptr<
Parallel::Communicator>>(
"_comm")),
456 _file_base_set_by_user(false),
457 _output_position_set(false),
458 _start_time_set(false),
460 _global_time_offset(0.0),
462 _action_factory(*this),
463 _action_warehouse(*this, _syntax, _action_factory),
464 _output_warehouse(*this),
466 _builder(*this, _action_warehouse, _parser),
468 _perf_graph(createRecoverablePerfGraph()),
469 _solution_invalidity(createRecoverableSolutionInvalidity()),
470 _rank_map(*_comm, _perf_graph),
471 _use_executor(_pars.
get<bool>(
"use_executor")),
472 _null_executor(NULL),
473 _use_nonlinear(true),
474 _use_eigen_value(false),
475 _enable_unused_check(ERROR_UNUSED),
477 _error_overridden(false),
478 _early_exit_param(
""),
479 _ready_to_exit(false),
481 _initial_from_file(false),
482 _distributed_mesh_on_command_line(false),
486 _use_split(_pars.
get<bool>(
"use_split")),
487 _force_restart(_pars.
get<bool>(
"force_restart")),
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") ? _pars.
get<unsigned
int>(
"_multiapp_level")
498 _multiapp_number(isParamValid(
"_multiapp_number") ? _pars.
get<unsigned
int>(
"_multiapp_number")
500 _use_master_mesh(_pars.
get<bool>(
"_use_master_mesh")),
501 _master_mesh(isParamValid(
"_master_mesh") ? _pars.
get<const
MooseMesh *>(
"_master_mesh")
503 _master_displaced_mesh(isParamValid(
"_master_displaced_mesh")
504 ? _pars.
get<const
MooseMesh *>(
"_master_displaced_mesh")
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
515 _libtorch_device(determineLibtorchDeviceType(getParam<
MooseEnum>(
"libtorch_device")))
517 #ifdef MOOSE_MFEM_ENABLED
519 _mfem_device(isParamValid(
"_mfem_device")
520 ? getParam<
std::shared_ptr<mfem::Device>>(
"_mfem_device")
523 isParamValid(
"_mfem_devices")
524 ?
std::set<
std::string>(getParam<
std::vector<
std::string>>(
"_mfem_devices").begin(),
525 getParam<
std::vector<
std::string>>(
"_mfem_devices").end())
526 :
std::set<
std::string>{})
529 if (¶meters != &_pars)
533 const std::string bad_params =
"(InputParameters parameters)";
534 const std::string good_params =
"(const InputParameters & parameters)";
535 const std::string source_constructor = type() +
"::" + type();
537 " copy-constructs its input parameters.\n\n",
538 "This is deprecated and will not be allowed in the future.\n\n",
561 const auto & timpi_sync = _pars.get<std::string>(
"timpi_sync");
564 #ifdef HAVE_GPERFTOOLS 565 if (isUltimateMaster())
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;
573 if (std::getenv(
"MOOSE_PROFILE_BASE"))
575 has_cpu_profiling =
true;
577 std::getenv(
"MOOSE_PROFILE_BASE") + std::to_string(_comm->rank()) +
".prof";
580 if (!
name.first.empty())
582 if (processor_id() == 0)
589 if (std::getenv(
"MOOSE_HEAP_BASE"))
591 has_heap_profiling =
true;
592 heap_profile_file = std::getenv(
"MOOSE_HEAP_BASE") + std::to_string(_comm->rank());
595 if (!
name.first.empty())
597 if (processor_id() == 0)
604 if (isParamSetByUser(
"gperf_profiler_on"))
606 auto rankstr = getParam<std::string>(
"gperf_profiler_on");
607 std::vector<processor_id_type> ranks;
610 mooseError(
"Invalid argument for --gperf-profiler-on: '", rankstr,
"'");
611 for (
auto & rank : ranks)
613 if (rank >= _comm->size())
614 mooseError(
"Invalid argument for --gperf-profiler-on: ",
616 " is greater than or equal to ",
618 if (rank == _comm->rank())
620 _cpu_profiling = has_cpu_profiling;
621 _heap_profiling = has_heap_profiling;
627 _cpu_profiling = has_cpu_profiling;
628 _heap_profiling = has_heap_profiling;
632 if (!ProfilerStart(cpu_profile_file.c_str()))
633 mooseError(
"CPU profiler is not started properly");
637 HeapProfilerStart(heap_profile_file.c_str());
638 if (!IsHeapProfilerRunning())
639 mooseError(
"Heap profiler is not started properly");
643 if (std::getenv(
"MOOSE_PROFILE_BASE") || std::getenv(
"MOOSE_HEAP_BASE"))
644 mooseError(
"gperftool is not available for CPU or heap profiling");
648 if (isParamValid(
"language_server") && getParam<bool>(
"language_server"))
649 _output_buffer_cache = Moose::out.rdbuf(
nullptr);
654 _the_warehouse = std::make_unique<TheWarehouse>();
657 _the_warehouse->registerAttribute<
AttribExecOns>(
"exec_ons", 0);
660 _the_warehouse->registerAttribute<
AttribThread>(
"thread", 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);
671 _the_warehouse->registerAttribute<
AttribSorted>(
"sorted");
674 _perf_graph.enableLivePrint();
676 if (isParamValid(
"_argc") && isParamValid(
"_argv"))
678 int argc = getParam<int>(
"_argc");
679 char ** argv = getParam<char **>(
"_argv");
681 _sys_info = std::make_unique<SystemInfo>(argc, argv);
683 if (isParamValid(
"_command_line"))
684 _command_line = getParam<std::shared_ptr<CommandLine>>(
"_command_line");
686 mooseError(
"Valid CommandLine object required");
688 if (_check_input && isParamSetByUser(
"recover"))
689 mooseError(
"Cannot run --check-input with --recover. Recover files might not exist");
691 if (isParamSetByUser(
"start_in_debugger") && isUltimateMaster())
693 auto command = getParam<std::string>(
"start_in_debugger");
695 Moose::out <<
"Starting in debugger using: " << command << std::endl;
699 std::stringstream command_stream;
702 command_stream <<
"xterm -e \"echo 'Rank: " << processor_id() <<
" Hostname: " <<
hostname 703 <<
" PID: " << getpid() <<
"'; echo ''; ";
706 if (command.find(
"lldb") != std::string::npos || command.find(
"gdb") != std::string::npos)
707 command_stream << command <<
" -p " << getpid();
711 "\nIf this is truly what you meant then contact moose-users to have a discussion " 712 "about adding your debugger.");
715 command_stream <<
"\"" 717 std::string command_string = command_stream.str();
718 Moose::out <<
"Running: " << command_string << std::endl;
720 int ret = std::system(command_string.c_str());
724 std::this_thread::sleep_for(std::chrono::seconds(10));
727 if (isParamSetByUser(
"stop_for_debugger") && isUltimateMaster())
729 Moose::out <<
"\nStopping for " << getParam<unsigned int>(
"stop_for_debugger")
730 <<
" seconds to allow attachment from a debugger.\n";
732 Moose::out <<
"\nAll of the processes you can connect to:\n";
733 Moose::out <<
"rank - hostname - pid\n";
740 Moose::err << processor_id() <<
" - " <<
hostname <<
" - " << getpid() <<
"\n";
743 Moose::out <<
"\nWaiting...\n" << std::endl;
746 std::this_thread::sleep_for(std::chrono::seconds(getParam<unsigned int>(
"stop_for_debugger")));
749 if (_master_mesh && isUltimateMaster())
750 mooseError(
"Mesh can be passed in only for sub-apps");
752 if (_master_displaced_mesh && !_master_mesh)
753 mooseError(
"_master_mesh should have been set when _master_displaced_mesh is set");
755 #ifdef MOOSE_MFEM_ENABLED 758 mooseAssert(!isUltimateMaster(),
759 "The MFEM device should only be auto-set for sub-applications");
760 mooseAssert(!_mfem_devices.empty(),
761 "If we are a sub-application and we have an MFEM device object, then we must know " 762 "its configuration string");
772 if (_pars.have_parameter<
bool>(
"use_legacy_dirichlet_bc"))
773 mooseDeprecated(
"The parameter 'use_legacy_dirichlet_bc' is no longer valid.\n\n",
774 "All Dirichlet boundary conditions are preset by default.\n\n",
775 "Remove said parameter in ",
777 " to remove this deprecation warning.");
779 if (_test_restep && _test_checkpoint_half_transient)
780 mooseError(
"Cannot use --test-restep and --test-checkpoint-half-transient together");
782 registerCapabilities();
784 Moose::out << std::flush;
791 auto haveCapability = [](
const std::string & capability,
const std::string & doc)
792 {
addCapability(capability,
true, doc +
" is available."); };
794 auto missingCapability =
795 [](
const std::string & capability,
const std::string & doc,
const std::string &
help =
"")
798 auto haveCapabilityVersion =
799 [](
const std::string & capability,
const std::string & doc,
const std::string & version)
800 {
addCapability(capability, version, doc +
" version " + version +
" is available."); };
802 auto petscMissingCapability = [](
const std::string & capability,
const std::string & doc)
805 capability,
false, doc +
" is not available. Check your PETSc configure options.");
808 auto libmeshMissingCapability =
809 [](
const std::string & capability,
const std::string & doc,
const std::string & config_option)
813 doc +
" is not available. It is controlled by the `" + config_option +
814 "` libMesh configure option.");
821 "Trapping floating point exceptions is enabled (in debug mode this " 822 "can be disabled using the --no-trap-fpe option).");
826 "Trapping floating point exceptions is not enabled (enable them using " 827 "the --trap-fpe option or by running a debug mode executable).");
830 const auto doc =
"LibTorch machine learning and parallel tensor algebra library";
831 #ifdef MOOSE_LIBTORCH_ENABLED 834 missingCapability(
"libtorch",
837 "https://mooseframework.inl.gov/moose/getting_started/installation/" 838 "install_libtorch.html for " 839 "instructions on how to configure and build moose with libTorch.");
844 const auto doc =
"MFEM finite element library";
845 #ifdef MOOSE_MFEM_ENABLED 846 haveCapability(
"mfem", doc);
848 missingCapability(
"mfem",
850 "Install mfem using the scripts/update_and_rebuild_mfem.sh script after " 851 "first running scripts/update_and_rebuild_conduit.sh. Finally, configure " 852 "moose with ./configure --with-mfem");
857 const auto doc =
"New Engineering Material model Library, version 2";
859 haveCapability(
"neml2", doc);
861 missingCapability(
"neml2",
863 "Install neml2 using the scripts/update_and_rebuild_neml2.sh script, then " 864 "configure moose with ./configure --with-neml2 --with-libtorch");
869 const auto doc =
"gperftools code performance analysis and profiling library";
870 #ifdef HAVE_GPERFTOOLS 871 haveCapability(
"gperftools", doc);
873 missingCapability(
"gperftools",
875 "Check https://mooseframework.inl.gov/application_development/profiling.html " 876 "for instructions on profiling MOOSE based applications.");
881 const auto doc =
"libPNG portable network graphics format library";
882 #ifdef MOOSE_HAVE_LIBPNG 883 haveCapability(
"libpng", doc);
885 missingCapability(
"libpng",
887 "Install libpng through conda or your distribution and check that it gets " 888 "detected through pkg-config, then reconfigure and rebuild MOOSE.");
893 const auto doc =
"NVIDIA GPU parallel computing platform";
894 #ifdef PETSC_HAVE_CUDA 895 haveCapability(
"cuda", doc);
897 missingCapability(
"cuda", doc,
"Add the CUDA bin directory to your path and rebuild PETSc.");
903 MOOSE_AD_MAX_DOFS_PER_ELEM,
904 "MOOSE was configured and built with a dual number backing store size of " +
906 ". Complex simulations with many variables or contact problems may require larger " 907 "values. Reconfigure MOOSE with the --with-derivative-size=<n> option in the root of the " 910 const std::string method = QUOTE(METHOD);
911 addCapability(
"method", method,
"The executable was built with METHOD=\"" + method +
"\"");
915 const std::string version = QUOTE(LIBMESH_DETECTED_PETSC_VERSION_MAJOR)
"." QUOTE(
916 LIBMESH_DETECTED_PETSC_VERSION_MINOR)
"." QUOTE(LIBMESH_DETECTED_PETSC_VERSION_SUBMINOR);
917 addCapability(
"petsc", version,
"Using PETSc version " + version +
".");
920 #ifdef LIBMESH_PETSC_USE_DEBUG 921 addCapability(
"petsc_debug",
true,
"PETSc was built with debugging options.");
923 addCapability(
"petsc_debug",
false,
"PETSc was built without debugging options.");
927 const auto doc =
"SuperLU direct solver";
928 #ifdef LIBMESH_PETSC_HAVE_SUPERLU_DIST 929 haveCapability(
"superlu", doc);
931 petscMissingCapability(
"superlu", doc);
936 const auto doc =
"MUltifrontal Massively Parallel sparse direct Solver (MUMPS)";
937 #ifdef LIBMESH_PETSC_HAVE_MUMPS 938 haveCapability(
"mumps", doc);
940 petscMissingCapability(
"mumps", doc);
945 const auto doc =
"STRUMPACK - STRUctured Matrix PACKage solver library";
946 #ifdef LIBMESH_PETSC_HAVE_STRUMPACK 947 haveCapability(
"strumpack", doc);
949 petscMissingCapability(
"strumpack", doc);
954 const auto doc =
"Parmetis partitioning library";
955 #if defined(LIBMESH_PETSC_HAVE_PARMETIS) || defined(LIBMESH_HAVE_PARMETIS) 956 haveCapability(
"parmetis", doc);
958 petscMissingCapability(
"parmetis", doc);
963 const auto doc =
"Chaco graph partitioning library";
964 #ifdef LIBMESH_PETSC_HAVE_CHACO 965 haveCapability(
"chaco", doc);
967 petscMissingCapability(
"chaco", doc);
972 const auto doc =
"Party matrix or graph partitioning library";
973 #ifdef LIBMESH_PETSC_HAVE_PARTY 974 haveCapability(
"party", doc);
976 petscMissingCapability(
"party", doc);
981 const auto doc =
"PT-Scotch graph partitioning library";
982 #ifdef LIBMESH_PETSC_HAVE_PTSCOTCH 983 haveCapability(
"ptscotch", doc);
985 petscMissingCapability(
"ptscotch", doc);
990 const auto doc =
"Scalable Library for Eigenvalue Problem Computations (SLEPc)";
991 #ifdef LIBMESH_HAVE_SLEPC 992 const auto version = QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_MAJOR)
"." QUOTE(
993 LIBMESH_DETECTED_SLEPC_VERSION_MINOR)
"." QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_SUBMINOR);
994 haveCapabilityVersion(
"slepc", doc, version);
996 petscMissingCapability(
"slepc", doc);
1001 const auto doc =
"Exodus mesh file format library";
1002 #ifdef LIBMESH_HAVE_EXODUS_API 1003 const std::string version = QUOTE(LIBMESH_DETECTED_EXODUS_VERSION_MAJOR)
"." QUOTE(
1004 LIBMESH_DETECTED_EXODUS_VERSION_MINOR);
1005 haveCapabilityVersion(
"exodus", doc, version);
1007 libmeshMissingCapability(
"exodus", doc,
"--enable-exodus");
1012 const auto doc =
"Netgen meshing library";
1013 #ifdef LIBMESH_HAVE_NETGEN 1014 haveCapability(
"netgen", doc);
1016 libmeshMissingCapability(
"netgen", doc,
"--enable-netgen");
1021 const auto doc =
"Visualization Toolkit (VTK)";
1022 #ifdef LIBMESH_HAVE_VTK 1023 const std::string version = QUOTE(LIBMESH_DETECTED_VTK_VERSION_MAJOR)
"." QUOTE(
1024 LIBMESH_DETECTED_VTK_VERSION_MINOR)
"." QUOTE(LIBMESH_DETECTED_VTK_VERSION_SUBMINOR);
1025 haveCapabilityVersion(
"vtk", doc, version);
1027 libmeshMissingCapability(
"vtk", doc,
"--disable-vtk and --enable-vtk-required");
1032 const auto doc =
"libcurl - the multiprotocol file transfer library";
1033 #ifdef LIBMESH_HAVE_CURL 1034 haveCapability(
"curl", doc);
1036 libmeshMissingCapability(
"curl", doc,
"--enable-curl");
1041 const auto doc =
"Tecplot post-processing tools API";
1042 #ifdef LIBMESH_HAVE_TECPLOT_API 1043 haveCapability(
"tecplot", doc);
1045 libmeshMissingCapability(
"tecplot", doc,
"--enable-tecplot");
1050 const auto doc =
"Boost C++ library";
1051 #ifdef LIBMESH_HAVE_EXTERNAL_BOOST 1052 haveCapability(
"boost", doc);
1054 libmeshMissingCapability(
"boost", doc,
"--with-boost");
1060 const auto doc =
"Adaptive mesh refinement";
1061 #ifdef LIBMESH_ENABLE_AMR 1062 haveCapability(
"amr", doc);
1064 libmeshMissingCapability(
"amr", doc,
"--disable-amr");
1069 const auto doc =
"nanoflann library for Nearest Neighbor (NN) search with KD-trees";
1070 #ifdef LIBMESH_HAVE_NANOFLANN 1071 haveCapability(
"nanoflann", doc);
1073 libmeshMissingCapability(
"nanoflann", doc,
"--disable-nanoflann");
1077 #ifdef LIBMESH_HAVE_FPARSER 1078 #ifdef LIBMESH_HAVE_FPARSER_JIT 1079 addCapability(
"fparser",
"jit",
"FParser enabled with just in time compilation support.");
1086 "FParser is disabled, libMesh was likely configured with --disable-fparser.");
1089 #ifdef LIBMESH_HAVE_DLOPEN 1091 "dlopen",
true,
"The dlopen() system call is available to dynamically load libraries.");
1095 "The dlopen() system call is not available. Dynamic library loading is " 1096 "not supported on this system.");
1100 const auto doc =
"LibMesh support for threaded execution";
1101 #ifdef LIBMESH_USING_THREADS 1102 haveCapability(
"threads", doc);
1104 libmeshMissingCapability(
"threads", doc,
"--with-thread-model=tbb,pthread,openmp,auto,none");
1109 const auto doc =
"OpenMP multi-platform shared-memory parallel programming API";
1110 #ifdef LIBMESH_HAVE_OPENMP 1111 haveCapability(
"openmp", doc);
1113 libmeshMissingCapability(
"openmp", doc,
"--with-thread-model=tbb,pthread,openmp,auto,none");
1117 const auto doc =
"oneAPI Threading Building Blocks (TBB) API";
1118 #ifdef LIBMESH_HAVE_TBB_API 1119 haveCapability(
"tbb", doc);
1121 libmeshMissingCapability(
"tbb", doc,
"--with-thread-model=tbb,pthread,openmp,auto,none");
1126 const auto doc =
"libMesh unique ID support";
1127 #ifdef LIBMESH_ENABLE_UNIQUE_ID 1128 haveCapability(
"unique_id", doc);
1130 libmeshMissingCapability(
"unique_id", doc,
"--enable-unique-id");
1135 const auto doc =
"libMesh default mesh mode";
1136 #ifdef LIBMESH_ENABLE_PARMESH 1146 " bytes for storage. This is controlled by the " 1147 "--with-dof-id-bytes=<1|2|4|8> libMesh configure option.");
1151 const auto doc =
"Compiler used to build the MOOSE framework.";
1152 #if defined(__clang__) 1154 #elif defined(__GNUC__) || defined(__GNUG__) 1156 #elif defined(_MSC_VER) 1165 const auto doc =
"Operating system this executable is running on.";
1172 #elif __unix__ // all unices not caught above 1180 #ifdef HAVE_GPERFTOOLS 1205 #ifdef LIBMESH_HAVE_DLOPEN 1208 dlclose(lib_pair.second.library_handle);
1215 return MOOSE_VERSION;
1221 return MOOSE_VERSION;
1233 TIME_SECTION(
"setupOptions", 5,
"Setting Up Options");
1236 if (
header().length() && !getParam<bool>(
"suppress_header"))
1239 if (getParam<bool>(
"error_unused"))
1241 else if (getParam<bool>(
"allow_unused"))
1244 if (getParam<bool>(
"error_override"))
1249 if (getParam<bool>(
"trap_fpe"))
1253 if (getParam<bool>(
"no_trap_fpe"))
1254 mooseError(
"Cannot use both \"--trap-fpe\" and \"--no-trap-fpe\" flags.");
1256 else if (getParam<bool>(
"no_trap_fpe"))
1268 auto color = getParam<MooseEnum>(
"color");
1272 if (getParam<bool>(
"no_color"))
1277 char * c_color = std::getenv(
"MOOSE_COLOR");
1279 color.assign(std::string(c_color),
"While assigning environment variable MOOSE_COLOR");
1283 if (color ==
"auto")
1285 else if (color ==
"on")
1287 else if (color ==
"off")
1290 mooseAssert(
false,
"Should not hit");
1293 if (getParam<bool>(
"no_color"))
1294 mooseDeprecated(
"The --no-color flag is deprecated. Use '--color off' instead.");
1303 #if !LIBMESH_USING_THREADS 1305 mooseError(
"You specified --n-threads > 1, but there is no threading model active!");
1309 if (getParam<bool>(
"minimal"))
1312 else if (getParam<bool>(
"display_version"))
1319 else if (getParam<bool>(
"help"))
1327 const std::string search =
1328 isParamSetByUser(
"dump_search") ? getParam<std::string>(
"dump_search") :
"";
1333 TIME_SECTION(
"dump", 1,
"Building Syntax Tree");
1338 if ((tree.getRoot()).is_object())
1344 Moose::out <<
"\n### START DUMP DATA ###\n" 1345 << formatter.
toString(tree.getRoot()) <<
"\n### END DUMP DATA ###" << std::endl;
1350 mooseError(
"Search parameter '", search,
"' was not found in the registered syntax.");
1352 else if (getParam<bool>(
"registry"))
1356 Moose::out <<
"Label\tType\tName\tClass\tFile\n";
1359 for (
auto & entry : objmap)
1360 for (
auto & obj : entry.second)
1361 Moose::out << entry.first <<
"\tobject\t" << obj->name() <<
"\t" << obj->_classname <<
"\t" 1362 << obj->_file <<
"\n";
1365 for (
auto & entry : actmap)
1367 for (
auto & act : entry.second)
1368 Moose::out << entry.first <<
"\taction\t" << act->_name <<
"\t" << act->_classname <<
"\t" 1369 << act->_file <<
"\n";
1374 else if (getParam<bool>(
"registry_hit"))
1378 Moose::out <<
"### START REGISTRY DATA ###\n";
1380 hit::Section root(
"");
1381 auto sec =
new hit::Section(
"registry");
1383 auto objsec =
new hit::Section(
"objects");
1384 sec->addChild(objsec);
1387 for (
auto & entry : objmap)
1388 for (
auto & obj : entry.second)
1390 auto ent =
new hit::Section(
"entry");
1391 objsec->addChild(ent);
1392 ent->addChild(
new hit::Field(
"label", hit::Field::Kind::String, entry.first));
1393 ent->addChild(
new hit::Field(
"type", hit::Field::Kind::String,
"object"));
1394 ent->addChild(
new hit::Field(
"name", hit::Field::Kind::String, obj->name()));
1395 ent->addChild(
new hit::Field(
"class", hit::Field::Kind::String, obj->_classname));
1396 ent->addChild(
new hit::Field(
"file", hit::Field::Kind::String, obj->_file));
1399 auto actsec =
new hit::Section(
"actions");
1400 sec->addChild(actsec);
1402 for (
auto & entry : actmap)
1403 for (
auto & act : entry.second)
1405 auto ent =
new hit::Section(
"entry");
1406 actsec->addChild(ent);
1407 ent->addChild(
new hit::Field(
"label", hit::Field::Kind::String, entry.first));
1408 ent->addChild(
new hit::Field(
"type", hit::Field::Kind::String,
"action"));
1409 ent->addChild(
new hit::Field(
"task", hit::Field::Kind::String, act->_name));
1410 ent->addChild(
new hit::Field(
"class", hit::Field::Kind::String, act->_classname));
1411 ent->addChild(
new hit::Field(
"file", hit::Field::Kind::String, act->_file));
1414 Moose::out << root.render();
1416 Moose::out <<
"\n### END REGISTRY DATA ###\n";
1420 else if (getParam<bool>(
"definition"))
1427 Moose::out <<
"%-START-SON-DEFINITION-%\n" 1428 << formatter.
toString(tree.
getRoot()) <<
"\n%-END-SON-DEFINITION-%\n";
1434 const std::string search =
1435 isParamSetByUser(
"yaml_search") ? getParam<std::string>(
"yaml_search") :
"";
1446 const std::string search =
1447 isParamSetByUser(
"json_search") ? getParam<std::string>(
"json_search") :
"";
1454 "json",
"**START JSON DATA**\n",
"\n**END JSON DATA**", tree.
getRoot().dump(2));
1458 else if (getParam<bool>(
"syntax"))
1463 std::stringstream ss;
1464 for (
const auto & it :
syntax)
1465 ss << it.first <<
"\n";
1470 else if (getParam<bool>(
"show_type"))
1474 Moose::out <<
"MooseApp Type: " <<
type() << std::endl;
1478 else if (getParam<bool>(
"show_capabilities"))
1482 "**START JSON DATA**\n",
1483 "\n**END JSON DATA**",
1490 const auto & capabilities = getParam<std::string>(
"check_capabilities");
1493 _console <<
"Capabilities '" << capabilities <<
"' are " << (pass ?
"" :
"not ") <<
"fulfilled." 1507 const auto & recover = getParam<std::string>(
"recover");
1523 const auto required_capabilities = getParam<std::string>(
"required_capabilities");
1524 auto [
status, reason, doc] =
1528 mooseInfo(
"Required capabilities '", required_capabilities,
"' not fulfilled.");
1536 required_capabilities,
1537 "' are not specific enough. A comparison test is performed on an undefined " 1538 "capability. Disambiguate this requirement by adding an existence/non-existence " 1539 "requirement. Example: 'unknown<1.2.3' should become 'unknown & unknown<1.2.3' " 1540 "or '!unknown | unknown<1.2.3'");
1544 auto isExclusiveParamSetByUser =
1545 [
this](
const std::vector<std::string> & group,
const std::string & param)
1549 for (
const auto & p : group)
1551 mooseError(
"Parameters '" + p +
"' and '" + param +
1552 "' are mutually exclusive. Please choose only one of them.");
1557 const std::vector<std::string> final_task_params = {
1558 "mesh_only",
"split_mesh",
"parse_neml2_only"};
1559 if (isExclusiveParamSetByUser(final_task_params,
"mesh_only"))
1573 else if (isExclusiveParamSetByUser(final_task_params,
"split_mesh"))
1581 else if (isExclusiveParamSetByUser(final_task_params,
"parse_neml2_only"))
1593 mooseAssert(common_actions.size() <= 1,
"Should not be more than one CommonOutputAction");
1594 const Action * common = common_actions.empty() ? nullptr : *common_actions.begin();
1597 if (common && common->isParamValid(
"file_base"))
1607 size_t pos = base.find_last_of(
'.');
1622 mooseError(
"You specified --check-input, but did not provide an input file. Add -i " 1623 "<inputfile> to your command line.");
1625 mooseError(
"No input files specified. Add -i <inputfile> to your command line.");
1627 else if (
isParamValid(
"language_server") && getParam<bool>(
"language_server"))
1652 Moose::out << std::flush;
1655 const std::vector<std::string> &
1658 mooseAssert(
_parser,
"Parser is not set");
1659 return _parser->getInputFileNames();
1665 mooseAssert(
_parser,
"Parser is not set");
1666 return _parser->getLastInputFileName();
1688 for (
auto & multi_app :
feProblem().getMultiAppWarehouse().getObjects())
1689 multi_app->setAppOutputFileBase();
1697 TIME_SECTION(
"runInputFile", 3);
1720 else if (getParam<bool>(
"list_constructed_objects"))
1725 std::stringstream ss;
1726 for (
const auto & obj :
_factory.getConstructedObjects())
1729 "list_constructed_objects",
"**START OBJECT DATA**\n",
"\n**END OBJECT DATA**", ss.str());
1751 "Something went wrong, we should only get here if _check_input is true.");
1753 "Incompatible command line arguments provided. --check-input cannot be called with ",
1758 mooseError(
"The Executor is being called without being initialized. This is likely " 1760 "incompatible command line arguments");
1764 for (
auto app : apps)
1765 for (
unsigned int i = 0; i < app->numLocalApps(); i++)
1766 app->localApp(i)->errorCheck();
1772 TIME_SECTION(
"executeExecutioner", 3);
1785 if (!result.convergedAll())
1798 mooseError(
"No executioner was specified (go fix your input file)");
1829 "MooseApp::hasRestartRecoverFileBase() instead.");
1840 case RESTARTABLE_FILTER::RECOVERABLE:
1848 std::vector<std::filesystem::path>
1851 TIME_SECTION(
"backup", 2,
"Backing Up Application to File");
1856 return writer.
write(folder_base);
1859 std::unique_ptr<Backup>
1862 TIME_SECTION(
"backup", 2,
"Backing Up Application");
1868 auto backup = std::make_unique<Backup>();
1877 TIME_SECTION(
"restore", 2,
"Restoring Application from File");
1890 TIME_SECTION(
"restore", 2,
"Restoring Application");
1895 mooseError(
"MooseApp::restore(): Provided backup is not initialized");
1898 mooseAssert(
header,
"Header not available");
1900 auto data = std::move(
backup->data);
1901 mooseAssert(data,
"Data not available");
1916 std::unique_ptr<Backup>
1920 mooseError(
"MooseApp::finalizeRestore(): Not currently restoring");
1925 std::unique_ptr<Backup>
backup;
1929 if (
auto header_string_input = dynamic_cast<StringInputStream *>(input_streams.header.get()))
1931 auto data_string_input =
dynamic_cast<StringInputStream *
>(input_streams.data.get());
1932 mooseAssert(data_string_input,
"Should also be a string input");
1934 auto header_sstream = header_string_input->release();
1935 mooseAssert(header_sstream,
"Header not available");
1937 auto data_sstream = data_string_input->release();
1938 mooseAssert(data_sstream,
"Data not available");
1940 backup = std::make_unique<Backup>();
1941 backup->header = std::move(header_sstream);
1942 backup->data = std::move(data_sstream);
1969 const std::string & name,
1975 mooseError(
"an executor with name '", executor->name(),
"' already exists");
1981 const std::string & name,
1990 mooseAssert(
_parser,
"Not set");
1996 std::list<std::string> & possible_roots,
1997 std::list<std::string> & current_branch)
2004 if (std::find(current_branch.begin(), current_branch.end(), current_executor_name) !=
2005 current_branch.end())
2007 std::stringstream exec_names_string;
2009 auto branch_it = current_branch.begin();
2011 exec_names_string << *branch_it++;
2013 for (; branch_it != current_branch.end(); ++branch_it)
2014 exec_names_string <<
", " << *branch_it;
2016 exec_names_string <<
", " << current_executor_name;
2018 mooseError(
"Executor cycle detected: ", exec_names_string.str());
2021 current_branch.push_back(current_executor_name);
2026 for (
const auto & param : params)
2028 if (params.have_parameter<ExecutorName>(param.first))
2030 const auto & dependency_name = params.get<ExecutorName>(param.first);
2032 possible_roots.remove(dependency_name);
2034 if (!dependency_name.empty())
2043 current_branch.pop_back();
2054 std::list<std::string> possibly_root;
2057 std::map<std::string, bool> already_built;
2060 std::list<std::string> possible_roots;
2063 std::list<std::string> current_branch;
2067 auto params =
_factory.getValidParams(
"NullExecutor");
2073 const auto &
name = params_entry.first;
2079 possible_roots.emplace_back(
name);
2085 if (possible_roots.size() > 1)
2087 auto root_string_it = possible_roots.begin();
2089 std::stringstream roots_string;
2091 roots_string << *root_string_it++;
2093 for (; root_string_it != possible_roots.end(); ++root_string_it)
2094 roots_string <<
", " << *root_string_it;
2096 mooseError(
"Multiple Executor roots found: ", roots_string.str());
2111 if (fail_if_not_found)
2132 TIME_SECTION(
"run", 3);
2133 if (getParam<bool>(
"show_docs"))
2137 mooseError(
"could not locate installed tests to run (unresolved binary/app name)");
2140 mooseError(
"no installed documentation found");
2146 std::ifstream ifs(docmsgfile);
2147 std::string content((std::istreambuf_iterator<char>(ifs)),
2148 (std::istreambuf_iterator<char>()));
2149 content.replace(content.find(
"$LOCAL_SITE_HOME"), content.length(), docmsg);
2153 Moose::out << docmsg <<
"\n";
2168 TIME_SECTION(
"setup", 2,
"Setting Up");
2172 catch (std::exception &
err)
2179 TIME_SECTION(
"execute", 2,
"Executing");
2186 Moose::err <<
"Syntax OK" << std::endl;
2193 if (getParam<bool>(
"show_inputs"))
2196 std::vector<std::string> dirs;
2199 if (installable_inputs ==
"")
2202 <<
"Show inputs has not been overriden in this application.\nContact the developers of " 2203 "this appication and request that they override \"MooseApp::getInstallableInputs\".\n";
2207 mooseAssert(!show_inputs_syntax.empty(),
"show_inputs sytnax should not be empty");
2210 Moose::out <<
"The following directories are installable into a user-writeable directory:\n\n" 2211 << installable_inputs <<
'\n' 2212 <<
"\nTo install one or more directories of inputs, execute the binary with the \"" 2213 << show_inputs_syntax[0] <<
"\" flag. e.g.:\n$ " 2214 <<
_command_line->getExecutableName() <<
' ' << show_inputs_syntax[0] <<
' ' 2233 if (
comm().size() > 1)
2234 mooseError(
"The --copy-inputs option should not be ran in parallel");
2237 auto dir_to_copy = getParam<std::string>(
"copy_inputs");
2239 if (dir_to_copy.empty())
2240 mooseError(
"Error retrieving directory to copy");
2241 if (dir_to_copy.back() !=
'/')
2248 mooseError(
"could not locate installed tests to run (unresolved binary/app name)");
2254 " to get a list of installable directories.");
2258 auto dst_dir =
_command_line->getExecutableNameBase() +
"/" + dir_to_copy;
2260 if (cmdname.find_first_of(
"/") != std::string::npos)
2261 cmdname = cmdname.substr(cmdname.find_first_of(
"/") + 1, std::string::npos);
2265 "The directory \"./",
2267 "\" already exists.\nTo update/recopy the contents of this directory, rename (\"mv ",
2269 " new_dir_name\") or remove (\"rm -r ",
2271 "\") the existing directory.\nThen re-run \"",
2277 std::string cmd =
"mkdir -p " + dst_dir +
"; rsync -av " + src_dir +
" " + dst_dir;
2279 TIME_SECTION(
"copy_inputs", 2,
"Copying Inputs");
2281 mooseAssert(
comm().size() == 1,
"Should be run in serial");
2282 const auto return_value = system(cmd.c_str());
2283 if (!WIFEXITED(return_value))
2287 Moose::out <<
"Directory successfully copied into ./" << dst_dir <<
'\n';
2298 if (
comm().size() > 1)
2299 mooseError(
"The --run option should not be ran in parallel");
2302 const auto find_run_it = std::as_const(*_command_line).findCommandLineParam(
"run");
2303 const auto & cl_entries = std::as_const(*_command_line).getEntries();
2304 mooseAssert(find_run_it != cl_entries.end(),
"Didn't find the option");
2305 std::string test_args;
2306 for (
auto it = std::next(find_run_it); it != cl_entries.end(); ++it)
2307 for (
const auto & arg : it->raw_args)
2309 test_args +=
" " + arg;
2318 mooseError(
"Could not locate binary name relative to installed location");
2322 "Could not locate installed tests from the current working directory:",
2324 ".\nMake sure you are executing this command from within a writable installed inputs ",
2325 "directory.\nRun \"",
2327 " --copy-inputs <dir>\" to copy the contents of <dir> to a \"./",
2329 "_<dir>\" directory.\nChange into that directory and try \"",
2331 " --run <dir>\" again.");
2335 setenv(
"MOOSE_TEST_RUNNER_APP_NAME",
appBinaryName().c_str(),
true);
2338 Moose::out <<
"Working Directory: " << working_dir <<
"\nRunning Command: " << cmd << std::endl;
2339 mooseAssert(
comm().size() == 1,
"Should be run in serial");
2340 const auto return_value = system(cmd.c_str());
2341 if (!WIFEXITED(return_value))
2361 std::list<std::string>
2365 std::list<std::string> checkpoint_dirs;
2372 for (
const auto & action : actions)
2376 if (!moose_object_action)
2380 if (moose_object_action->
getParam<std::string>(
"type") ==
"Checkpoint")
2384 const std::string cp_dir =
2387 checkpoint_dirs.push_back(cp_dir +
"_cp");
2390 return checkpoint_dirs;
2393 std::list<std::string>
2428 std::string library_name(app_name);
2431 size_t pos = library_name.find(
"App");
2432 if (pos != library_name.length() - 3)
2433 mooseError(
"Invalid application name: ", library_name);
2434 library_name.erase(pos);
2438 QUOTE(METHOD) +
".la";
2444 std::string app_name(library_name);
2447 if (pcrecpp::RE(
"lib(.+?)(?:-\\w+)?\\.la").Replace(
"\\1", &app_name) == 0)
2448 mooseError(
"Invalid library name: ", app_name);
2459 if (!metaname.empty() && tid != 0)
2461 "The meta data storage for '", metaname,
"' is not threaded, so the tid must be zero.");
2463 mooseAssert(metaname.empty() ||
2465 "The desired meta data name does not exist: " + metaname);
2474 if (data->typeId() != stored_data->
typeId())
2475 mooseError(
"Type mismatch found in RestartableData registration of '",
2477 "'\n\n Stored type: ",
2478 stored_data->
type(),
2483 stored_data = &data_map.addData(std::move(data));
2488 return *stored_data;
2493 std::unique_ptr<RestartableDataValue> data,
2498 mooseDeprecated(
"The use of MooseApp::registerRestartableData with a data name is " 2499 "deprecated.\n\nUse the call without a name instead.");
2501 mooseAssert(
name == data->name(),
"Inconsistent name");
2512 return it->second.first.hasData(
name);
2522 "The meta data storage for '", metaname,
"' is not threaded, so the tid must be zero.");
2528 mooseError(
"Unable to find RestartableDataValue object with name " +
name +
2529 " in RestartableDataMap");
2536 const std::filesystem::path & folder_base)
2544 reader.
setInput(meta_data_folder_base);
2556 std::vector<std::filesystem::path>
2558 const std::filesystem::path & folder_base)
2561 mooseError(
"MooseApp::writeRestartableMetaData(): Should only run on processor 0");
2567 return writer.
write(meta_data_folder_base);
2570 std::vector<std::filesystem::path>
2573 std::vector<std::filesystem::path> paths;
2579 paths.insert(paths.end(), map_paths.begin(), map_paths.end());
2587 std::string library_path,
2588 const std::string & library_name,
2591 #ifdef LIBMESH_HAVE_DLOPEN 2593 params.
set<std::string>(
"app_name") = app_name;
2595 params.
set<std::string>(
"registration_method") = app_name +
"__registerApps";
2596 params.
set<std::string>(
"library_path") = library_path;
2598 const auto effective_library_name =
2600 params.
set<std::string>(
"library_name") = effective_library_name;
2601 params.
set<
bool>(
"library_load_dependencies") = lib_load_deps;
2604 std::ostringstream oss;
2606 auto successfully_loaded =
false;
2608 oss <<
'"' << app_name <<
"\" is not a registered application name.\n" 2609 <<
"No search paths were set. We made no attempts to locate the corresponding library " 2618 oss <<
'"' << app_name <<
"\" is not a registered application name.\n" 2619 <<
"Unable to locate library archive for \"" << app_name
2620 <<
"\".\nWe attempted to locate the library archive \"" << effective_library_name
2621 <<
"\" in the following paths:\n\t";
2622 std::copy(paths.begin(), paths.end(), infix_ostream_iterator<std::string>(oss,
"\n\t"));
2625 successfully_loaded =
true;
2628 if (!successfully_loaded)
2630 oss <<
"\nMake sure you have compiled the library and either set the \"library_path\" " 2631 "variable in your input file or exported \"MOOSE_LIBRARY_PATH\".\n";
2637 libmesh_ignore(app_name, library_path, library_name, lib_load_deps);
2638 mooseError(
"Dynamic Loading is either not supported or was not detected by libMesh configure.");
2647 std::string library_path,
2648 const std::string & library_name)
2650 #ifdef LIBMESH_HAVE_DLOPEN 2652 params.
set<std::string>(
"app_name") = app_name;
2654 params.
set<std::string>(
"registration_method") = app_name +
"__registerAll";
2655 params.
set<std::string>(
"library_path") = library_path;
2656 params.
set<std::string>(
"library_name") =
2662 params.
set<
bool>(
"library_load_dependencies") =
false;
2667 mooseError(
"Dynamic Loading is either not supported or was not detected by libMesh configure.");
2675 const auto library_name = params.
get<std::string>(
"library_name");
2678 for (
const auto & path : paths)
2681 path +
'/' + library_name, params, params.
get<
bool>(
"library_load_dependencies"));
2687 const bool load_dependencies)
2690 std::string dl_lib_filename;
2694 pcrecpp::RE re_deps(
"(/\\S*\\.la)");
2696 std::ifstream la_handle(library_filename.c_str());
2697 if (la_handle.is_open())
2699 while (std::getline(la_handle, line))
2702 if (line.find(
"dlname=") != std::string::npos)
2705 dl_lib_filename = line.substr(8, line.size() - 9);
2707 if (line.find(
"dependency_libs=") != std::string::npos)
2709 if (load_dependencies)
2711 pcrecpp::StringPiece input(line);
2712 pcrecpp::StringPiece depend_library;
2713 while (re_deps.FindAndConsume(&input, &depend_library))
2727 if (dl_lib_filename.empty())
2746 #ifdef LIBMESH_HAVE_DLOPEN 2747 void *
const lib_handle = dlopen(dl_lib_full_path.c_str(), RTLD_LAZY);
2749 void *
const lib_handle =
nullptr;
2755 "\" exists and has proper permissions, but cannot by dynamically loaded.\nThis " 2756 "generally means that the loader was unable to load one or more of the " 2757 "dependencies listed in the supplied library (see otool or ldd).\n",
2764 auto insert_ret =
_lib_handles.insert(std::make_pair(file_name, lib_info));
2765 mooseAssert(insert_ret.second ==
true,
"Error inserting into lib_handles map");
2767 dyn_lib_it = insert_ret.first;
2771 const auto registration_method = params.
get<std::string>(
"registration_method");
2772 auto & entry_sym_from_curr_lib = dyn_lib_it->second.entry_symbols;
2774 if (entry_sym_from_curr_lib.find(registration_method) == entry_sym_from_curr_lib.end())
2780 #ifdef LIBMESH_HAVE_DLOPEN 2781 void * registration_handle =
2782 dlsym(dyn_lib_it->second.library_handle, registration_method.c_str());
2784 void * registration_handle =
nullptr;
2787 if (registration_handle)
2793 using register_app_t =
void (*)();
2794 register_app_t *
const reg_ptr =
reinterpret_cast<register_app_t *
>(®istration_handle);
2801 register_app_t *
const reg_ptr =
reinterpret_cast<register_app_t *
>(®istration_handle);
2811 entry_sym_from_curr_lib.insert(registration_method);
2816 #if defined(DEBUG) && defined(LIBMESH_HAVE_DLOPEN) 2820 if (!registration_handle)
2822 registration_method,
2826 "This doesn't necessarily indicate an error condition unless you believe that " 2827 "the method should exist in that library.\n",
2834 std::set<std::string>
2838 std::set<std::string> paths;
2840 paths.insert(it.first);
2845 std::set<std::string>
2848 std::set<std::string> paths;
2850 if (!library_path.empty())
2852 std::vector<std::string> tmp_paths;
2855 paths.insert(tmp_paths.begin(), tmp_paths.end());
2858 char * moose_lib_path_env = std::getenv(
"MOOSE_LIBRARY_PATH");
2859 if (moose_lib_path_env)
2861 std::string moose_lib_path(moose_lib_path_env);
2862 std::vector<std::string> tmp_paths;
2865 paths.insert(tmp_paths.begin(), tmp_paths.end());
2880 return std::string(
"");
2898 TIME_SECTION(
"createMinimalApp", 3,
"Creating Minimal App");
2904 action_params.
set<std::string>(
"type") =
"GeneratedMesh";
2907 std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<
MooseObjectAction>(
2913 params.set<
unsigned int>(
"nx") = 1;
2923 action_params.
set<std::string>(
"type") =
"Transient";
2926 std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<
MooseObjectAction>(
2931 params.
set<
unsigned int>(
"num_steps") = 1;
2932 params.set<
Real>(
"dt") = 1;
2942 action_params.
set<
bool>(
"_solve") =
false;
2945 std::shared_ptr<Action> action = std::static_pointer_cast<
Action>(
2956 action_params.
set<
bool>(
"console") =
false;
2959 std::shared_ptr<Action> action =
2974 [&
name](
const std::shared_ptr<RelationshipManager> & rm)
2983 auto & existing_for_whom = acceptor.
forWhom();
2986 for (
auto & fw : donor.
forWhom())
2988 if (std::find(existing_for_whom.begin(), existing_for_whom.end(), fw) ==
2989 existing_for_whom.end())
3013 std::set<std::shared_ptr<RelationshipManager>> rms_to_erase;
3017 if (*existing_rm >= *new_rm)
3020 donateForWhom(*new_rm, *existing_rm);
3025 else if (*new_rm >= *existing_rm)
3026 rms_to_erase.emplace(existing_rm);
3032 for (
const auto & rm_to_erase : rms_to_erase)
3034 donateForWhom(*rm_to_erase, *new_rm);
3046 static const std::string suffix =
"-mesh.cpa.gz";
3050 std::filesystem::path
3052 const std::string & map_suffix)
3055 std::filesystem::path(
"meta_data" + map_suffix));
3058 std::filesystem::path
3061 auto folder = folder_base;
3062 folder +=
"-restart-" + std::to_string(
processor_id());
3070 return action->parameters().getHitNode();
3087 mooseError(
"The template rm does not exist in our _template_to_clones map");
3089 auto & mesh_to_clone_map = outer_it->second;
3090 auto inner_it = mesh_to_clone_map.find(&
mesh);
3091 if (inner_it == mesh_to_clone_map.end())
3092 mooseError(
"We should have the mesh key in our mesh");
3094 return *inner_it->second;
3104 const MeshBase *
const undisp_lm_mesh =
mesh->getMeshPtr();
3106 if (undisp_lm_mesh &&
hasRMClone(*rm, *undisp_lm_mesh))
3108 undisp_clone = &
getRMClone(*rm, *undisp_lm_mesh);
3109 const_cast<MeshBase *
>(undisp_lm_mesh)->remove_ghosting_functor(*undisp_clone);
3113 MeshBase *
const disp_lm_mesh = displaced_mesh ? &displaced_mesh->getMesh() :
nullptr;
3115 if (disp_lm_mesh &&
hasRMClone(*rm, *disp_lm_mesh))
3117 disp_clone = &
getRMClone(*rm, *disp_lm_mesh);
3126 problem.removeAlgebraicGhostingFunctor(*undisp_clone);
3127 problem.removeCouplingGhostingFunctor(*undisp_clone);
3130 auto * dp = problem.getDisplacedProblem().get();
3131 if (dp && disp_clone)
3132 dp->removeAlgebraicGhostingFunctor(*disp_clone);
3135 _factory.releaseSharedObjects(*rm);
3143 const DofMap *
const dof_map)
3146 auto it = mesh_to_clone.find(&
mesh);
3147 if (it != mesh_to_clone.end())
3150 auto & clone_rm = *it->second;
3151 if (!clone_rm.dofMap() && dof_map)
3153 clone_rm.init(moose_mesh,
mesh, dof_map);
3154 else if (clone_rm.dofMap() && dof_map && (clone_rm.dofMap() != dof_map))
3155 mooseError(
"Attempting to create and initialize an existing clone with a different DofMap. " 3156 "This should not happen.");
3166 auto pr = mesh_to_clone.emplace(
3167 std::make_pair(&const_cast<const MeshBase &>(
mesh),
3168 dynamic_pointer_cast<RelationshipManager>(template_rm.
clone())));
3169 mooseAssert(pr.second,
"An insertion should have happened");
3170 auto & clone_rm = *pr.first->second;
3171 clone_rm.init(moose_mesh,
mesh, dof_map);
3182 if (rm->attachGeometricEarly())
3195 if (moose_mesh_base != &mesh)
3196 mooseError(
"The MooseMesh MeshBase and the MeshBase we're trying to attach " 3197 "relationship managers to are different");
3210 bool attach_geometric_rm_final)
3214 if (!rm->isType(rm_type))
3228 if (!rm->attachGeometricEarly() && !attach_geometric_rm_final)
3231 mesh->allowRemoteElementRemoval(
false);
3235 const DofMap *
const undisp_sys_dof_map =
3243 attach_geometric_rm_final && disp_moose_mesh)
3246 const DofMap * disp_sys_dof_map =
nullptr;
3253 mooseError(
"The displaced mesh should not yet exist at the time that we are attaching " 3254 "early geometric relationship managers.");
3264 mooseError(
"We must have an executioner by now or else we do not have to data to add " 3265 "algebraic or coupling functors to in MooseApp::attachRelationshipManagers");
3269 auto & undisp_moose_mesh = problem.mesh();
3271 auto & undisp_sys_dof_map = undisp_sys.
dofMap();
3272 auto & undisp_mesh = undisp_moose_mesh.getMesh();
3274 if (rm->useDisplacedMesh() && problem.getDisplacedProblem())
3288 problem.addCouplingGhostingFunctor(
3296 auto & disp_mesh = disp_moose_mesh.getMesh();
3306 problem.addCouplingGhostingFunctor(
3311 problem.addAlgebraicGhostingFunctor(
3323 std::vector<std::pair<std::string, std::string>>
3326 std::vector<std::pair<std::string, std::string>> info_strings;
3331 std::stringstream oss;
3332 oss << rm->getInfo();
3334 auto & for_whom = rm->forWhom();
3336 if (!for_whom.empty())
3340 std::copy(for_whom.begin(), for_whom.end(), infix_ostream_iterator<std::string>(oss,
", "));
3343 info_strings.emplace_back(std::make_pair(
Moose::stringify(rm->getType()), oss.str()));
3354 std::map<std::string, unsigned int> counts;
3362 counts[
demangle(
typeid(*gf).name())]++;
3365 for (
const auto & pair : counts)
3366 info_strings.emplace_back(std::make_pair(
3367 "Default", pair.first + (pair.second > 1 ?
" x " + std::to_string(pair.second) :
"")));
3378 std::map<std::string, unsigned int> counts;
3380 for (
auto & gf :
as_range(d_mesh->getMesh().ghosting_functors_begin(),
3381 d_mesh->getMesh().ghosting_functors_end()))
3386 counts[
demangle(
typeid(*gf).name())]++;
3389 for (
const auto & pair : counts)
3390 info_strings.emplace_back(
3391 std::make_pair(
"Default",
3392 pair.first + (pair.second > 1 ?
" x " + std::to_string(pair.second) :
"") +
3393 " for DisplacedMesh"));
3396 return info_strings;
3408 std::vector<std::string> not_declared;
3410 for (
const auto & data : meta_data)
3411 if (!data.declared())
3412 not_declared.push_back(data.name());
3414 if (!not_declared.empty())
3416 std::ostringstream oss;
3418 not_declared.begin(), not_declared.end(), infix_ostream_iterator<std::string>(oss,
", "));
3422 "' meta-data properties were retrieved but never declared: ",
3436 mooseError(
"Unable to find RestartableDataMap object for the supplied name '",
3438 "', did you call registerRestartableDataMapName in the application constructor?");
3439 return iter->second.first;
3451 if (!suffix.empty())
3452 std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
3453 suffix.insert(0,
"_");
3463 mooseError(
"MooseApp::getRestartableDataMapName: The name '",
name,
"' is not registered");
3464 return it->second.second;
3473 std::make_unique<RestartableData<PerfGraph>>(
"perf_graph",
3477 getParam<bool>(
"perf_graph_live_all"),
3478 !getParam<bool>(
"disable_perf_graph_live"));
3490 auto solution_invalidity =
3491 std::make_unique<RestartableData<SolutionInvalidity>>(
"solution_invalidity",
nullptr, *
this);
3505 #ifdef MOOSE_LIBTORCH_ENABLED 3509 if (device_enum ==
"cuda")
3512 if (!torch::cuda::is_available())
3513 mooseError(
"--libtorch-device=cuda: CUDA is not available");
3514 return torch::kCUDA;
3516 mooseError(
"--libtorch-device=cuda: CUDA is not supported on your platform");
3519 else if (device_enum ==
"mps")
3522 if (!torch::mps::is_available())
3523 mooseError(
"--libtorch-device=mps: MPS is not available");
3526 mooseError(
"--libtorch-device=mps: MPS is not supported on your platform");
3530 mooseAssert(device_enum ==
"cpu",
"Should be cpu");
3537 const std::string & start_marker,
3538 const std::string & end_marker,
3539 const std::string & data)
const 3544 Moose::out << start_marker << data << end_marker << std::endl;
3549 const auto & filename = getParam<std::string>(param);
3551 std::ofstream
out(filename.c_str());
3554 std::ofstream
out(filename.c_str());
3555 out << data << std::flush;
3559 mooseError(
"Unable to open file `", filename,
"` for writing ", param,
" data to it.");
3565 const std::string & doc)
3576 #ifdef MOOSE_MFEM_ENABLED 3581 auto string_set = std::set<std::string>(string_vec.begin(), string_vec.end());
3584 _mfem_device = std::make_shared<mfem::Device>(device_string);
3588 else if (!device_string.empty() && string_set !=
_mfem_devices)
3589 mooseError(
"Attempted to configure with MFEM devices '",
3591 "', but we have already configured the MFEM device object with the devices '",
std::string name(const ElemQuality q)
std::list< std::string > getCheckpointFiles() const
Extract all possible checkpoint file names.
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
std::list< std::string > getCheckpointDirectories() const
Get all checkpoint directories.
static const std::string & checkpointSuffix()
The file suffix for the checkpoint mesh.
std::string getFileName(bool stripLeadingPath=true) const
Return the primary (first) filename that was parsed Note: When stripLeadingPath is false...
std::string docsDir(const std::string &app_name)
Returns the directory of any installed docs/site.
void build()
Parse an input file (or text string if provided) consisting of hit syntax and setup objects in the MO...
void addExecutorParams(const std::string &type, const std::string &name, const InputParameters ¶ms)
Adds the parameters for an Executor to the list of parameters.
virtual std::string getPrintableName() const
Get printable name of the application.
unsigned int _multiapp_level
Level of multiapp, the master is level 0. This used by the Console to indent output.
virtual std::string getInstallableInputs() const
Method to retrieve the installable inputs from a given applications <app>Revision.h file.
void write(std::ostream &header_stream, std::ostream &data_stream)
Writes the restartable data to header stream header_stream and data stream data_stream.
PerfGraph & _perf_graph
The PerfGraph object for this application (recoverable)
bool show_trace
Set to true (the default) to print the stack trace with error and warning messages - false to omit it...
void setOutputPosition(const Point &p)
Tell the app to output in a specific position.
std::string join(Iterator begin, Iterator end, const std::string &delimiter)
Python-like join function for strings over an iterator range.
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> ...
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
std::map< Moose::RelationshipManagerType, std::set< const RelationshipManager * > > _attached_relationship_managers
The relationship managers that have been attached (type -> RMs)
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...
void dynamicRegistration(const libMesh::Parameters ¶ms)
Helper method for dynamic loading of objects.
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 ...
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
virtual void setupOptions()
Setup options based on InputParameters.
PerfGraph & createRecoverablePerfGraph()
Creates a recoverable PerfGraph.
std::shared_ptr< DisplacedProblem > displaced_problem
std::string libNameToAppName(const std::string &library_name) const
Converts a library name to an application name:
const unsigned int invalid_uint
RelationshipManagerType
Main types of Relationship Managers.
void registerCapabilities()
Register all base MooseApp capabilities to the Moose::Capabilities registry.
const std::shared_ptr< Parser > _parser
Parser for parsing the input file.
std::string getFrameworkVersion() const
Returns the framework version.
Base class for everything in MOOSE with a name and a type.
const std::multimap< std::string, ActionInfo > & getAssociatedActions() const
Return all Syntax to Action associations.
void setRecover(bool value)
void buildFullTree(const std::string &search_string)
Use MOOSE Factories to construct a full parse tree for documentation or echoing input.
std::vector< std::pair< std::string, std::string > > getRelationshipManagerInfo() const
Returns the Relationship managers info suitable for printing.
bool hasRMClone(const RelationshipManager &template_rm, const MeshBase &mesh) const
torch::DeviceType determineLibtorchDeviceType(const MooseEnum &device) const
Function to determine the device which should be used by libtorch on this application.
bool _file_base_set_by_user
Whether or not file base is set through input or setOutputFileBase by MultiApp.
const Action * getCurrentAction() const
bool _output_position_set
Whether or not an output position has been set for this app.
void addDependency(const std::string &task, const std::string &pre_req)
std::unique_ptr< TheWarehouse > _the_warehouse
The combined warehouse for storing any MooseObject based object.
InputParameters getValidParams(const std::string &name)
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 ...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
bool hasInitialBackup() const
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...
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)
bool _warnings_are_errors
Variable to toggle any warning into an error (includes deprecated code warnings)
std::string installedInputsDir(const std::string &app_name, const std::string &dir_name, const std::string &extra_error_msg="")
Returns the directory of any installed inputs or the empty string if none are found.
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
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.
static const RestartableDataMapName MESH_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.
void registerTaskName(const std::string &task, bool should_auto_build=false)
Method to register a new task.
virtual const std::type_info & typeId() const =0
The type ID of the underlying data.
std::shared_ptr< MooseMesh > & displacedMesh()
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.
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
virtual std::string appBinaryName() const
const std::shared_ptr< MooseMesh > & getMesh() const
std::string getOutputFileBase(bool for_non_moose_build_output=false) const
Get the output file base name.
static void addInputParam(InputParameters ¶ms)
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
RelationshipManager & getRMClone(const RelationshipManager &template_rm, const MeshBase &mesh) const
Return the relationship manager clone originally created from the provided template relationship mana...
void setFinalTask(const std::string &task)
bool runInputs()
Handles the run input parameter logic: Checks to see whether a directory exists in user space and lau...
void registerRestartableNameWithFilter(const std::string &name, Moose::RESTARTABLE_FILTER filter)
NOTE: This is an internal function meant for MOOSE use only!
virtual void run()
Run the application.
void removeRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Purge this relationship manager from meshes and DofMaps and finally from us.
Real _start_time
The time at which to start the simulation.
Writer for restartable data, to be read by the RestartableDataReader.
This attribute describes sorting state.
void createExecutors()
After adding all of the Executor Params - this function will actually cause all of them to be built...
void recursivelyCreateExecutors(const std::string ¤t_executor_name, std::list< std::string > &possible_roots, std::list< std::string > ¤t_branch)
Internal function used to recursively create the executor objects.
bool forceRestart() const
Whether or not we are forcefully restarting (allowing the load of potentially incompatibie checkpoint...
std::filesystem::path restartFolderBase(const std::filesystem::path &folder_base) const
The file suffix for restartable data.
std::pair< std::filesystem::path, std::filesystem::path > splitFileName(const T &full_file)
Function for splitting path and filename.
void remove_ghosting_functor(GhostingFunctor &ghosting_functor)
void setMFEMDevice(const std::string &device_string, Moose::PassKey< MFEMExecutioner >)
Create/configure the MFEM device with the provided device_string.
bool hasRelationshipManager(const std::string &name) const
Returns a Boolean indicating whether a RelationshipManater exists with the same name.
std::list< std::string > getFilesInDirs(const std::list< std::string > &directory_list, const bool files_only=true)
Retrieves the names of all of the files contained within the list of directories passed into the rout...
bool _check_input
true if we want to just check the input file
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
const Parallel::Communicator & comm() const
const InputParameters & _pars
Parameters of this object.
bool isParamValid(const std::string &name) const
bool hasRestartableDataMap(const RestartableDataMapName &name) const
void addActionBlock(std::shared_ptr< Action > blk)
This method add an Action instance to the warehouse.
std::set< std::string > _mfem_devices
MFEM supported devices based on user-provided config.
Syntax _syntax
Syntax of the input file.
Syntax & syntax()
Returns a writable reference to the syntax object.
std::map< std::string, std::shared_ptr< Executor > > _executors
Pointers to all of the Executors for this run.
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.
ExecuteMooseObjectWarehouse< MultiApp > & getMultiAppWarehouse()
bool _trap_fpe
Whether or not FPE trapping should be turned on.
int exitCode() const
Get the shell exit code for the application.
processor_id_type processor_id() const
Returns the MPI processor ID of the current processor.
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.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
Helper class to hold streams for Backup and Restore operations.
const hit::Node * getCurrentActionHitNode() const
ActionWarehouse _action_warehouse
Where built actions are stored.
std::string realpath(const std::string &path)
Wrapper around PetscGetRealPath, which is a cross-platform replacement for realpath.
RestartableDataReader _rd_reader
void checkMetaDataIntegrity() const
Function to check the integrity of the restartable meta data structure.
const std::list< Action * > & getActionListByName(const std::string &task) const
Retrieve a constant list of Action pointers associated with the passed in task.
virtual const std::vector< std::string > & forWhom() const
The object (or Action) this RelationshipManager was built for.
static InputParameters validParams()
bool isRestarting() const
Whether or not this is a "restart" calculation.
bool isSplitMesh() const
Whether or not this is a split mesh operation.
RestartableDataMap & getRestartableDataMap(const RestartableDataMapName &name)
Return a reference to restartable data for the specific type flag.
Holds the syntax in a Json::Value tree.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters()
Get the parameters of the object.
virtual const std::string & name() const
Get the name of the class.
std::string hostname()
Get the hostname the current process is running on.
FEProblemBase & feProblem() const
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters ¶meters)
MooseApp(const InputParameters ¶meters)
Constructor is protected so that this object is constructed through the AppFactory object...
void allowRemoteElementRemoval(bool allow_removal)
Set whether to allow remote element removal.
std::vector< RestartableDataMap > _restartable_data
Where the restartable data is held (indexed on tid)
std::string camelCaseToUnderscore(const std::string &camel_case_name)
Function for converting a camel case name to a name containing underscores.
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 ...
void setOutputFileBase(const std::string &output_file_base)
Override the selection of the output file base name.
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
Python like split functions for strings.
int _exit_code
The exit code.
Storage for restartable data that is ordered based on insertion order.
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...
std::shared_ptr< MooseMesh > & mesh()
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
void mooseInfo(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
MeshGeneratorSystem _mesh_generator_system
The system that manages the MeshGenerators.
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...
const MeshBase * getMeshPtr() const
bool _start_time_set
Whether or not an start time has been set.
virtual libMesh::DofMap & dofMap()
Gets writeable reference to the dof map.
void allow_remote_element_removal(bool allow)
void libmesh_ignore(const Args &...)
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.
bool showInputs() const
Prints a message showing the installable inputs for a given application (if getInstallableInputs has ...
bool addRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Transfers ownership of a RelationshipManager to the application for lifetime management.
RestartableDataValue & getRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname, THREAD_ID tid)
std::shared_ptr< NullExecutor > _null_executor
Used to return an executor that does nothing.
const T & get(std::string_view) const
const std::string & getLastInputFileName() const
virtual void preBackup()
Insertion point for other apps that is called before backup()
InputParameters & getObjectParams()
Retrieve the parameters of the object to be created by this action.
void setErrorOverridden()
Set a flag so that the parser will throw an error if overridden parameters are detected.
void resetFileBase()
Resets the file base for all FileOutput objects.
virtual void postRestore(const bool)
Insertion point for other apps that is called after restore()
T command_line_value(const std::string &, T)
void loadLibraryAndDependencies(const std::string &library_filename, const libMesh::Parameters ¶ms, bool load_dependencies=true)
Recursively loads libraries and dependencies in the proper order to fully register a MOOSE applicatio...
virtual std::unique_ptr< Base > create()=0
Tracks the libmesh system number that a MooseObject is associated with.
std::shared_ptr< CommandLine > _command_line
Command line object.
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...
bool _restart
Whether or not this is a restart run.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::unique_ptr< Backup > backup()
Backs up the application memory in a Backup.
bool _deprecated_is_error
Variable to toggle only deprecated warnings as errors.
Generic AppFactory class for building Application objects.
RESTARTABLE_FILTER
The filter type applied to a particular piece of "restartable" data.
void clearAppParams(const InputParameters ¶ms, const ClearAppParamsKey)
Clears the stored parameters for the given application parameteres.
void meshChanged()
Calls the meshChanged method for every output object.
void setErrorOnLoadWithDifferentNumberOfProcessors(bool value)
void setActive(bool active)
Turn on or off timing.
RestartableDataValue & registerRestartableData(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
void initSyntaxFormatter(SyntaxFormatterType type, bool dump_mode)
Creates a syntax formatter for printing.
Specialized factory for generic Action System objects.
bool checkFileReadable(const std::string &filename, bool check_line_endings=false, bool throw_on_unreadable=true, bool check_for_git_lfs_pointer=true)
Checks to see if a file is readable (exists and permissions)
An inteface for the _console for outputting to the Console object.
void setRestart(bool value)
Sets the restart/recover flags.
AttribBoundaries tracks all boundary IDs associated with an object.
std::shared_ptr< Executioner > _executioner
Pointer to the executioner of this run (typically build by actions)
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
ActionFactory _action_factory
The Factory responsible for building Actions.
std::string runTestsExecutable()
Returns the location of either a local repo run_tests script - or an installed test executor script i...
void disableLivePrint()
Completely disables Live Print (cannot be restarted)
const std::string & type() const
Get the type of this class.
void restoreFromInitialBackup(const bool for_restart)
Restores from a "initial" backup, that is, one set in _initial_backup.
std::string underscoreToCamelCase(const std::string &underscore_name, bool leading_upper_case)
Function for converting an underscore name to a camel case name.
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
RegistrationType
Enumeration for holding the valid types of dynamic registrations allowed.
Executioners are objects that do the actual work of solving your problem.
enum MooseApp::UNUSED_CHECK _enable_unused_check
bool _recover
Whether or not this is a recovery run.
void buildJsonSyntaxTree(JsonSyntaxTree &tree) const
Use MOOSE Factories to construct a parameter tree for documentation or echoing input.
Point _output_position
The output position.
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
void errorCheck(const libMesh::Parallel::Communicator &comm, bool warn_unused, bool err_unused)
const nlohmann::json & getRoot() const
Get the root of the tree.
bool _error_overridden
Indicates whether warnings or errors are displayed when overridden parameters are detected...
virtual std::string getVersion() const
Returns the current version of the framework or application (default: framework version).
SolutionInvalidity & createRecoverableSolutionInvalidity()
Creates a recoverable SolutionInvalidity.
bool _heap_profiling
Memory profiling.
std::string getPrimaryFileName(bool stripLeadingPath=true) const
Return the primary (first) filename that was parsed.
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
std::string stringify(const T &t)
conversion to string
Class for storing and utilizing output objects.
std::string demangle(const char *name)
void addForWhom(const std::string &for_whom)
Add another name to for_whom.
Interface for objects interacting with the PerfGraph.
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
std::set< std::string > getLibrarySearchPaths(const std::string &library_path_from_param) const
Return the paths searched by MOOSE when loading libraries.
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.
void outputMachineReadableData(const std::string ¶m, 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...
static std::filesystem::path restartableDataFolder(const std::filesystem::path &folder_base)
virtual std::string type() const =0
String identifying the type of parameter stored.
static AppFactory & instance()
Get the instance of the AppFactory.
Residual objects have this attribute.
const std::string & getCurrentTaskName() const
const std::string & getRestartableDataMapName(const RestartableDataMapName &name) const
static Capabilities & getCapabilityRegistry()
bool hasRecoverFileBase() const
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...
bool hasRestartRecoverFileBase() const
Return true if the recovery file base is set.
void registerRestartableDataMapName(const RestartableDataMapName &name, std::string suffix="")
Reserve a location for storing custom RestartableDataMap objects.
void restore(const std::filesystem::path &folder_base, const bool for_restart)
Restore an application from file.
bool _trap_fpe
Variable indicating whether we will enable FPE trapping for this run.
void loadRestartableMetaData(const std::filesystem::path &folder_base)
Loads all available restartable meta data if it is available with the folder base folder_base...
std::filesystem::path pathjoin(const std::filesystem::path &p)
std::set< GhostingFunctor *>::const_iterator ghosting_functors_begin() const
virtual void executeExecutioner()
Execute the Executioner that was built.
bool _distributed_mesh_on_command_line
This variable indicates that DistributedMesh should be used for the libMesh mesh underlying MooseMesh...
void addExecutor(const std::string &type, const std::string &name, const InputParameters ¶ms)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
PetscErrorCode petscSetupOutput(CommandLine *cmd_line)
void add_command_line_name(const std::string &name)
Moose::Builder _builder
Builder for building app related parser tree.
const std::shared_ptr< MooseMesh > & getDisplacedMesh() const
std::string RestartableDataMapName
std::set< std::shared_ptr< RelationshipManager > > _relationship_managers
The relationship managers that have been added.
OutputWarehouse _output_warehouse
OutputWarehouse object for this App.
std::string _output_file_base
The output file basename.
std::streambuf * _output_buffer_cache
Cache output buffer so the language server can turn it off then back on.
static void addAppParam(InputParameters ¶ms)
bool _cpu_profiling
CPU profiling.
T & set(const std::string &)
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
Concrete definition of a parameter value for a specified type.
void build()
Builds all auto-buildable tasks.
void registerAll(Factory &f, ActionFactory &af, Syntax &s)
Register objects that are in MOOSE.
virtual void runInputFile()
Actually build everything in the input file.
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
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.
Holding syntax for parsing input files.
class infix_ostream_iterator if void
std::unordered_set< std::string > DataNames
static const std::string MESH_META_DATA_SUFFIX
SolverSystem & getSolverSystem(unsigned int sys_num)
Get non-constant reference to a solver system.
void executeAllActions()
This method loops over all actions in the warehouse and executes them.
std::unique_ptr< InputParameterWarehouse > _input_parameter_warehouse
Input parameter storage structure; unique_ptr so we can control its destruction order.
virtual std::unique_ptr< GhostingFunctor > clone() const
std::string getCurrentWorkingDir()
Returns the current working directory as a string.
const std::vector< std::string > & getInputFileNames() const
Tracks whether the object is on the displaced mesh.
static void addCapability(const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
register a new capability
InputStreams clear()
Clears the contents of the reader (header stream, data stream, header)
void makedirs(const std::string &dir_name, bool throw_on_failure=false)
Recursively make directories.
std::unique_ptr< Backup > finalizeRestore()
Finalizes (closes) the restoration process done in restore().
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool appendingMeshGenerators() const
Whether or not mesh generators are currently being appended (append_mesh_generator task) ...
static const std::string allow_data_driven_param
The name of the boolean parameter on the MooseApp that will enable data driven generation.
void restore(const DataNames &filter_names={})
Restores the restartable data.
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.
const DataNames & getRecoverableData() const
Return a reference to the recoverable data object.
void setDeclared(const SetDeclaredKey)
Sets that this restartable value has been declared.
const std::shared_ptr< libMesh::Parallel::Communicator > _comm
The MPI communicator this App is going to use.
std::string getPrintableVersion() const
Non-virtual method for printing out the version string in a consistent format.
std::shared_ptr< mfem::Device > _mfem_device
The MFEM Device object.
std::vector< const T * > getActions()
Retrieve all actions in a specific type ordered by their names.
bool pathExists(const std::string &path)
void createMinimalApp()
Method for creating the minimum required actions for an application (no input file) ...
void setExitCode(const int exit_code)
Sets the exit code that the application will exit with.
bool isRecovering() const
Whether or not this is a "recover" calculation.
DataNames _recoverable_data_names
Data names that will only be read from the restart file during RECOVERY.
Executor * getExecutor() const
The PerfGraph will hold the master list of all registered performance segments and the head PerfNode...
bool copyInputs()
Handles the copy_inputs input parameter logic: Checks to see whether the passed argument is valid (a ...
void clear()
This method deletes all of the Actions in the warehouse.
A scope guard that guarantees that whatever happens between when it gets created and when it is destr...
void disableCheckUnusedFlag()
Removes warnings and error checks for unrecognized variables in the input file.
void add(const std::string &capability, CapabilityUtils::Type value, const std::string &doc)
register a new capability
bool _split_mesh
Whether or not we are performing a split mesh operation (–split-mesh)
void ErrorVector unsigned int
const bool _use_executor
Indicates whether we are operating in the new/experimental executor mode instead of using the legacy ...
Abstract definition of a RestartableData value.
Class for parsing input files.
Meta-action for creating common output object parameters This action serves two purpose, first it adds common output object parameters.
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
std::string getExecutableName()
This function returns the name of the running executable.
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)
static char addKnownLabel(const std::string &label)
addKnownLabel whitelists a label as valid for purposes of the checkLabels function.
std::set< GhostingFunctor *>::const_iterator ghosting_functors_end() const
void setStartTime(Real time)
Set the starting time for the simulation.
std::shared_ptr< Executor > _executor
Pointer to the Executor of this run.
The Executor class directs the execution flow of simulations.
void add_ghosting_functor(GhostingFunctor &ghosting_functor)
std::string findTestRoot()
Searches in the current working directory and then recursively up in each parent directory looking fo...
void errorCheck()
Runs post-initialization error checking that cannot be run correctly unless the simulation has been f...
std::set< std::string > getLoadedLibraryPaths() const
Return the paths of loaded libraries.
std::string _early_exit_param
Indicates if simulation is ready to exit, and keeps track of which param caused it to exit...
static bool isAvailable(const std::filesystem::path &folder_base)
void dynamicAppRegistration(const std::string &app_name, std::string library_path, const std::string &library_name, bool lib_load_deps)
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 ...
bool isParamSetByUser(const std::string &nm) const