Moose.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "libmesh/petsc_macro.h"
#include "libmesh/libmesh_config.h"
 
#include "Moose.h"
#include "MooseApp.h"
 
#include "ActionWarehouse.h"
#include "ActionFactory.h"
#include "AuxiliarySystem.h"
#include "Factory.h"
#include "PetscSupport.h"
#include "Syntax.h"
#include "MooseSyntax.h"
#include "ExecFlagRegistry.h"
#include "FVGradientMethod.h"
 
#include "hit/parse.h"
 
#include <unistd.h>
 
const ExecFlagType EXEC_NONE = registerDefaultExecFlag("NONE");
const ExecFlagType EXEC_INITIAL = registerDefaultExecFlag("INITIAL");
const ExecFlagType EXEC_LINEAR = registerDefaultExecFlag("LINEAR");
const ExecFlagType EXEC_LINEAR_CONVERGENCE = registerDefaultExecFlag("LINEAR_CONVERGENCE");
const ExecFlagType EXEC_NONLINEAR = registerDefaultExecFlag("NONLINEAR");
const ExecFlagType EXEC_NONLINEAR_CONVERGENCE = registerDefaultExecFlag("NONLINEAR_CONVERGENCE");
const ExecFlagType EXEC_POSTCHECK = registerDefaultExecFlag("POSTCHECK");
const ExecFlagType EXEC_TIMESTEP_END = registerDefaultExecFlag("TIMESTEP_END");
const ExecFlagType EXEC_TIMESTEP_BEGIN = registerDefaultExecFlag("TIMESTEP_BEGIN");
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_ITERATION_END =
    registerExecFlag("MULTIAPP_FIXED_POINT_ITERATION_END");
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END =
    registerDefaultExecFlag("MULTIAPP_FIXED_POINT_END");
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN =
    registerDefaultExecFlag("MULTIAPP_FIXED_POINT_BEGIN");
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE =
    registerDefaultExecFlag("MULTIAPP_FIXED_POINT_CONVERGENCE");
const ExecFlagType EXEC_MULTISYSTEM_FIXED_POINT_ITERATION_END =
    registerDefaultExecFlag("MULTISYSTEM_FIXED_POINT_ITERATION_END");
const ExecFlagType EXEC_FINAL = registerDefaultExecFlag("FINAL");
const ExecFlagType EXEC_FORCED = registerExecFlag("FORCED");
const ExecFlagType EXEC_FAILED = registerExecFlag("FAILED");
const ExecFlagType EXEC_CUSTOM = registerDefaultExecFlag("CUSTOM");
const ExecFlagType EXEC_SUBDOMAIN = registerExecFlag("SUBDOMAIN");
const ExecFlagType EXEC_ALWAYS = registerExecFlag("ALWAYS");
const ExecFlagType EXEC_PRE_DISPLACE = registerExecFlag("PRE_DISPLACE");
const ExecFlagType EXEC_SAME_AS_MULTIAPP = registerExecFlag("SAME_AS_MULTIAPP");
const ExecFlagType EXEC_PRE_MULTIAPP_SETUP = registerExecFlag("PRE_MULTIAPP_SETUP");
const ExecFlagType EXEC_TRANSFER = registerExecFlag("TRANSFER");
const ExecFlagType EXEC_PRE_KERNELS = registerExecFlag("PRE_KERNELS");
#ifdef LIBMESH_ENABLE_AMR
const ExecFlagType EXEC_POST_ADAPTIVITY = registerExecFlag("POST_ADAPTIVITY");
#endif
 
namespace Moose
{
 
bool
isSolverExecFlag(const ExecFlagType & exec_flag)
{
  return exec_flag == EXEC_LINEAR || exec_flag == EXEC_NONLINEAR || exec_flag == EXEC_POSTCHECK;
}
 
void associateSyntaxInner(Syntax & syntax, ActionFactory & action_factory);
 
void
registerAll(Factory & f, ActionFactory & af, Syntax & s)
{
  registerObjects(f, {"MooseApp"});
  associateSyntaxInner(s, af);
  registerActions(s, af, {"MooseApp"});
  registerAppDataFilePath("moose");
  registerRepository("moose", "github.com/idaholab/moose");
 
  // Citation emitted by the --citations command-line option: the current framework paper is tied to
  // "MooseApp" (so it is cited whenever a MooseApp object is used, and apps composed of MooseApp
  // inherit it), and modules register their own app citations (via Registry::addAppCitation) which
  // are cited only when one of their objects is actually used. PETSc and its sub-packages register
  // their own citations, which --citations emits through PETSc.
  Registry::addAppCitation("MooseApp",
                           "harbour2025moose",
                           R"(@article{harbour2025moose,
  title = {4.0 {MOOSE}: Enabling massively parallel Multiphysics simulation},
  journal = {{SoftwareX}},
  volume = {31},
  pages = {102264},
  year = {2025},
  issn = {2352-7110},
  doi = {https://doi.org/10.1016/j.softx.2025.102264},
  url = {https://www.sciencedirect.com/science/article/pii/S2352711025002316},
  author = {Logan Harbour and Guillaume Giudicelli and Alexander D. Lindsay and Peter German and Joshua Hansel and Casey Icenhour and Mengnan Li and Jason M. Miller and Roy H. Stogner and Patrick Behne and Daniel Yankura and Zachary M. Prince and Corey DeChant and Daniel Schwen and Benjamin W. Spencer and Mauricio Tano and Namjae Choi and Yaqi Wang and Max Nezdyur and Yinbin Miao and Tianchen Hu and Shikhar Kumar and Christopher Matthews and Brandon Langley and Nuno Nobre and Alexander Blair and Chris MacMackin and Henrique Bergallo Rocha and Edward Palmer and Jesse Carter and J{\"o}rg Meier and Andrew E. Slaughter and David Andr{\v{s}} and Robert W. Carlsen and Fande Kong and Derek R. Gaston and Cody J. Permann},
})");
 
  // The libMesh citation is registered under "libMesh" but not tied to any object label, so the
  // per-object loop in MooseApp::requestCitations() does not emit it; emission is gated on the
  // finite element backend actually used in the run.
  Registry::addAppCitation("libMesh",
                           "libMeshPaper",
                           R"(@article{libMeshPaper,
  author = {B.~S.~Kirk and J.~W.~Peterson and R.~H.~Stogner and G.~F.~Carey},
  title = {{\texttt{libMesh}: A C++ Library for Parallel Adaptive Mesh
              Refinement/Coarsening Simulations}},
  journal = {Engineering with Computers},
  volume = {22},
  number = {3--4},
  pages = {237--254},
  year = {2006},
  url={http://dx.doi.org/10.1007/s00366-006-0049-3}
})");
 
#ifdef MOOSE_MFEM_ENABLED
  // Like libMesh, the MFEM citation is emitted by MooseApp::requestCitations() only when the run
  // actually uses the MFEM backend.
  Registry::addAppCitation("MFEM",
                           "mfem-2024",
                           R"(@article{mfem-2024,
  title = {High-Performance Finite Elements with {MFEM}},
  author = {J. Andrej and N. Atallah and J.-P. B{\"a}cker and J.-S. Camier and D. Copeland and V. Dobrev and Y. Dudouit and T. Duswald and B. Keith and D. Kim and T. Kolev and B. Lazarov and K. Mittal and W. Pazner and S. Petrides and S. Shiraiwa and M. Stowell and V. Tomov},
  journal = {The International Journal of High Performance Computing Applications},
  volume = {38},
  number = {5},
  pages = {447--467},
  year = {2024},
  publisher = {SAGE Publications Sage UK: London, England},
})");
#endif
}
 
void
registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
{
  Registry::registerObjectsTo(factory, obj_labels);
}
 
void
addActionTypes(Syntax & syntax)
{
  // clang-format off
  /**************************/
  /**** Register Actions ****/
  /**************************/
  registerMooseObjectTask("create_problem",               Problem,                   false);
  registerMooseObjectTask("setup_executioner",            Executioner,               false);
  registerMooseObjectTask("read_executor",                Executor,                  false);
  registerTask("add_executor", true);
 
  // TODO Organize these somewhere
  registerTask("init_physics", false);
  registerTask("init_component_physics", false);
  registerTask("meta_action_component", false);
  registerTask("setup_component", false);
  // 'list_component' is used to retrieve ActionComponents for the syntax JSON
  registerTask("list_component", false);
 
  // This task does not construct an object, but it needs all of the parameters that
  // would normally be used to construct an object.
  registerMooseObjectTask("determine_system_type",            Executioner,               true);
 
  registerMooseObjectTask("setup_mesh",                       MooseMesh,                 false);
  registerMooseObjectTask("set_mesh_base",                    MooseMesh,                 false);
  registerMooseObjectTask("init_mesh",                        MooseMesh,                 false);
  registerMooseObjectTask("add_mesh_generator",               MeshGenerator,             false);
  registerTask("create_added_mesh_generators", true);
  registerMooseObjectTask("append_mesh_generator",            MeshGenerator,             false);
 
  registerMooseObjectTask("add_kernel",                       Kernel,                    false);
  appendMooseObjectTask  ("add_kernel",                       EigenKernel);
  appendMooseObjectTask  ("add_kernel",                       VectorKernel);
  appendMooseObjectTask  ("add_kernel",                       ArrayKernel);
  appendMooseObjectTask  ("add_kernel",                       ADArrayKernel);
 
  registerMooseObjectTask("add_variable",                     MooseVariableBase,         false);
  registerMooseObjectTask("add_aux_variable",                 MooseVariableBase,         false);
  registerMooseObjectTask("add_elemental_field_variable",     MooseVariableBase,         false);
  registerMooseObjectTask("add_variables_physics",            MooseVariableBase,         false);
 
  registerMooseObjectTask("add_nodal_kernel",                 NodalKernel,               false);
 
  registerMooseObjectTask("add_functor_material",             FunctorMaterial,           false);
  registerMooseObjectTask("add_material",                     MaterialBase,              false);
  appendDeprecatedMooseObjectTask("add_material",             FunctorMaterial);
  registerMooseObjectTask("add_materials_physics",            FunctorMaterial,           false);
  appendMooseObjectTask  ("add_materials_physics",            MaterialBase);
 
  registerMooseObjectTask("add_bc",                           BoundaryCondition,         false);
 
  registerMooseObjectTask("add_function",                     Function,                  false);
 
  registerMooseObjectTask("add_distribution",                 Distribution,              false);
  registerMooseObjectTask("add_sampler",                      Sampler,                   false);
 
  registerMooseObjectTask("add_aux_kernel",                   AuxKernel,                 false);
  appendMooseObjectTask  ("add_aux_kernel",                   VectorAuxKernel);
  appendMooseObjectTask  ("add_aux_kernel",                   ArrayAuxKernel);
 
  registerMooseObjectTask("add_bound",                        Bounds,                    false);
 
  registerMooseObjectTask("add_scalar_kernel",                ScalarKernel,              false);
  registerMooseObjectTask("add_aux_scalar_kernel",            AuxScalarKernel,           false);
  registerMooseObjectTask("add_dirac_kernel",                 DiracKernel,               false);
  appendMooseObjectTask  ("add_dirac_kernel",                 VectorDiracKernel);
  registerMooseObjectTask("add_dg_kernel",                    DGKernel,                  false);
  registerMooseObjectTask("add_fv_kernel",                    FVKernel,                  false);
  registerMooseObjectTask("add_gradient_method",              FVGradientMethod,          false);
  registerMooseObjectTask("add_interpolation_method",         FVInterpolationMethod,     false);
  registerMooseObjectTask("add_interpolation_method_physics", FVInterpolationMethod,     false);
  registerMooseObjectTask("add_linear_fv_kernel",             LinearFVKernel,            false);
  registerMooseObjectTask("add_fv_bc",                        FVBoundaryCondition,       false);
  registerMooseObjectTask("add_linear_fv_bc",                 LinearFVBoundaryCondition, false);
  registerMooseObjectTask("add_fv_ik",                        FVInterfaceKernel,         false);
  registerMooseObjectTask("add_interface_kernel",             InterfaceKernel,           false);
  appendMooseObjectTask  ("add_interface_kernel",             VectorInterfaceKernel);
  registerMooseObjectTask("add_constraint",                   Constraint,                false);
  registerMooseObjectTask("add_hybridized_kernel",            HDGKernel,                 false);
  registerMooseObjectTask("add_hybridized_integrated_bc",     HDGIntegratedBC,           false);
 
  registerMooseObjectTask("add_ic",                           InitialCondition,          false);
  appendMooseObjectTask  ("add_ic",                           ScalarInitialCondition);
  registerMooseObjectTask("add_fv_ic",                        FVInitialCondition,        false);
  registerMooseObjectTask("add_ics_physics",                  InitialCondition,          false);
  appendMooseObjectTask  ("add_ics_physics",                  FVInitialCondition);
  appendMooseObjectTask  ("add_ics_physics",                  ScalarInitialCondition);
 
  registerMooseObjectTask("add_damper",                       Damper,                    false);
  registerMooseObjectTask("setup_predictor",                  Predictor,                 false);
  registerMooseObjectTask("add_time_steppers",                TimeStepper,               false);
  registerMooseObjectTask("add_time_stepper",                 TimeStepper,               false);
  registerTask           ("compose_time_stepper",                                    true);
  registerMooseObjectTask("setup_time_integrators",           TimeIntegrator,            false);
  registerMooseObjectTask("setup_time_integrator",            TimeIntegrator,            false);
  registerMooseObjectTask("add_convergence",                  Convergence,               false);
 
  registerMooseObjectTask("add_preconditioning",              MoosePreconditioner,       false);
  registerMooseObjectTask("add_field_split",                  Split,                     false);
 
  registerMooseObjectTask("add_mesh_division",                MeshDivision,              false);
  registerMooseObjectTask("add_user_object",                  UserObject,                false);
  appendMooseObjectTask  ("add_user_object",                  Postprocessor);
 
  appendDeprecatedMooseObjectTask("add_user_object",          Corrector);
  registerMooseObjectTask("add_corrector",                    Corrector,                 false);
  appendDeprecatedMooseObjectTask("add_user_object",          MeshModifier);
  registerMooseObjectTask("add_mesh_modifier",                MeshModifier,              false);
 
  registerMooseObjectTask("add_postprocessor",                Postprocessor,             false);
  registerMooseObjectTask("add_vector_postprocessor",         VectorPostprocessor,       false);
  registerMooseObjectTask("add_reporter",                     Reporter,                  false);
 
  registerMooseObjectTask("add_positions",                    Positions,                 false);
  registerMooseObjectTask("add_times",                        Times,                     false);
 
  registerMooseObjectTask("add_indicator",                    Indicator,                 false);
  registerMooseObjectTask("add_marker",                       Marker,                    false);
 
  registerMooseObjectTask("add_multi_app",                    MultiApp,                  false);
  registerMooseObjectTask("add_transfer",                     Transfer,                  false);
 
  registerMooseObjectTask("add_output",                       Output,                    false);
 
  registerMooseObjectTask("add_control",                      Control,                   false);
  registerMooseObjectTask("add_chain_control",                ChainControl,              false);
  registerMooseObjectTask("add_partitioner",                  MoosePartitioner,          false);
 
  // clang-format on
 
  registerTask("dynamic_object_registration", false);
  registerTask("common_output", true);
  registerTask("setup_recover_file_base", true);
  registerTask("recover_meta_data", true);
 
  registerTask("add_bounds_vectors", false);
  registerTask("add_periodic_bc", false);
  registerTask("add_aux_variable", false);
  registerTask("add_external_aux_variables", true);
  registerTask("add_variable", false);
  registerTask("add_mortar_variable", false);
 
  registerTask("execute_mesh_generators", true);
  registerTask("uniform_refine_mesh", false);
  registerTask("prepare_mesh", false);
  registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
  registerTask("setup_mesh_complete", true); // calls prepare
  registerTask("post_mesh_prepared", false);
  registerTask("add_geometric_rm", false);
  registerTask("attach_geometric_rm", true);
  registerTask("attach_geometric_rm_final", true);
 
  registerTask("init_displaced_problem", false);
 
  registerTask("add_algebraic_rm", false);
  registerTask("attach_algebraic_rm", true);
  registerTask("add_coupling_rm", false);
  registerTask("attach_coupling_rm", true);
  registerTask("init_problem", true);
  registerTask("check_copy_nodal_vars", true);
  registerTask("copy_nodal_vars", true);
  registerTask("copy_nodal_aux_vars", true);
  registerTask("copy_vars_physics", false);
  registerTask("setup_postprocessor_data", false);
  registerTask("setup_time_steppers", true);
 
  registerTask("setup_dampers", true);
  registerTask("check_integrity", true);
  registerTask("resolve_optional_materials", true);
  registerTask("check_integrity_early", true);
  registerTask("check_integrity_early_physics", false);
  registerTask("setup_quadrature", true);
  registerTask("create_tagged_matrices", true);
 
  registerTask("mesh_modifiers", false);
 
  registerTask("no_action", false); // Used for Empty Action placeholders
  registerTask("set_global_params", false);
  registerTask("setup_adaptivity", false);
  registerTask("meta_action", false);
  registerTask("setup_residual_debug", false);
  registerTask("setup_oversampling", false);
  registerTask("deprecated_block", false);
  registerTask("set_adaptivity_options", false);
  registerTask("add_mortar_interface", false);
  registerTask("coupling_functor_check", true);
  registerTask("add_master_action_material", false);
  registerTask("setup_projected_properties", false);
  registerTask("create_application_block", false);
 
  // Dummy Actions (useful for sync points in the dependencies)
  registerTask("setup_function_complete", false);
  registerTask("setup_variable_complete", false);
  registerTask("setup_executioner_complete", false);
  registerTask("ready_to_init", true);
 
  // Output related actions
  registerTask("add_output_aux_variables", true);
  registerTask("check_output", true);
  registerTask("declare_late_reporters", true);
 
  registerTask("create_problem_default", true);
  registerTask("create_problem_custom", false);
  registerTask("create_problem_complete", false);
 
  registerTask("add_default_nonlinear_convergence", true);
  registerTask("add_default_multiapp_fixed_point_convergence", true);
  registerTask("add_default_steady_state_convergence", true);
 
  registerTask("chain_control_setup", true);
  registerTask("start_webservercontrol", true);
 
  // Action for setting up the signal-based checkpoint
  registerTask("auto_checkpoint_action", true);
  /**************************/
  /****** Dependencies ******/
  /**************************/
  // clang-format off
  syntax.addDependencySets("(meta_action)"
                           "(meta_action_component)"
                           "(dynamic_object_registration)"
                           "(common_output)"
                           "(set_global_params)"
                           "(setup_recover_file_base)"
                           "(check_copy_nodal_vars)"
                           "(setup_mesh)"
                           "(add_geometric_rm)"
                           "(add_partitioner)"
                           "(add_mesh_generator)"
                           "(create_added_mesh_generators)"
                           "(append_mesh_generator)"
                           "(execute_mesh_generators)"
                           "(recover_meta_data)"
                           "(set_mesh_base)"
                           "(attach_geometric_rm)"
                           "(init_mesh)"
                           "(prepare_mesh)"
                           "(add_mortar_interface)"
                           "(uniform_refine_mesh)"
                           "(setup_mesh_complete)"
                           "(post_mesh_prepared)"
                           "(determine_system_type)"
                           "(create_problem)"
                           "(create_problem_custom)"
                           "(create_problem_default)"
                           "(create_problem_complete)"
                           "(init_displaced_problem)" // Problem must be init-ed before we start adding functors
                           "(add_function)"  // Functions can depend on scalar variables & PPs, but this dependence can be
                                             // added on initialSetup() rather than construction
                           "(init_component_physics)" // components must add their blocks to physics before init_physics
                           "(init_physics)"
                           "(setup_postprocessor_data)"
                           "(setup_time_integrator, setup_time_integrators)"
                           "(setup_executioner)"
                           "(setup_executioner_complete)"
                           "(setup_component)"  // no particular reason for that placement
                           "(read_executor)"
                           "(add_executor)"
                           "(check_integrity_early)"
                           "(setup_predictor)"
                           "(add_aux_variable, add_variable, add_elemental_field_variable,"
                           " add_external_aux_variables)"
                           "(add_variables_physics)" // physics can skip adding variables if they already exist
                           "(add_mortar_variable)"
                           "(setup_variable_complete)"
                           "(check_integrity_early_physics)"  // checks that systems and variables are consistent
                           "(setup_quadrature)"
                           "(add_convergence)"
                           "(add_default_nonlinear_convergence,"
                           " add_default_multiapp_fixed_point_convergence,"
                           " add_default_steady_state_convergence)"
                           "(add_positions)"
                           "(add_periodic_bc)"
                           "(add_gradient_method)"
                           "(add_user_object, add_corrector, add_mesh_modifier)"
                           "(add_field_split)" // split objects required before field split preconditioner itself
                           "(add_preconditioning)" // preconditioner may introduce objects such as static condensation which influence the underlying types of tagged matrices
                           "(create_tagged_matrices)"
                           "(add_distribution)"
                           "(add_sampler)"
                           "(setup_function_complete)"
                           "(setup_adaptivity)"
                           "(set_adaptivity_options)"
                           "(add_ic, add_fv_ic)"
                           "(add_ics_physics)" // physics can skip adding initial conditions if they already exist
                           "(add_constraint)"
                           "(add_times)"
                           "(add_time_stepper, add_time_steppers)"
                           "(compose_time_stepper)"
                           "(setup_time_steppers)"
                           "(ready_to_init)"
                           "(setup_dampers)"
                           "(setup_residual_debug)"
                           "(add_bounds_vectors)"
                           "(add_mesh_division)"  // NearestPositionsDivision uses a Positions
                           "(add_multi_app)"
                           "(add_transfer)"
                           "(copy_nodal_vars, copy_nodal_aux_vars, copy_vars_physics)"
                           "(add_material)"
                           "(add_master_action_material)"
                           "(add_functor_material)"
                           "(add_materials_physics)"
                           "(setup_projected_properties)"
                           "(add_output_aux_variables)"
                           "(add_output)"
                           "(auto_checkpoint_action)"
                           "(add_postprocessor)"
                           "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
                                                        // to be after material objects are created.
                           "(add_reporter)"
                           "(declare_late_reporters)"
                           "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
                           " add_nodal_kernel, add_dg_kernel, add_fv_kernel, add_interpolation_method,"
                           " add_interpolation_method_physics, add_linear_fv_kernel,"
                           " add_fv_bc, add_linear_fv_bc, add_fv_ik, add_interface_kernel,"
                           " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker,"
                           " add_bound, add_hybridized_kernel, add_hybridized_integrated_bc)"
                           "(resolve_optional_materials)"
                           "(add_algebraic_rm)"
                           "(add_coupling_rm)"
                           "(attach_geometric_rm_final)"
                           "(attach_algebraic_rm)"
                           "(attach_coupling_rm)"
                           "(coupling_functor_check)"
                           "(delete_remote_elements_after_late_geometric_ghosting)"
                           "(init_problem)"
                           "(add_control, add_chain_control)"
                           "(chain_control_setup)"
                           "(start_webservercontrol)"
                           "(check_output)"
                           "(check_integrity)"
                           "(create_application_block)");
  // clang-format on
 
#ifdef MOOSE_MFEM_ENABLED
  registerTask("add_mfem_problem_operator", true);
  addTaskDependency("add_variable", "add_mfem_problem_operator");
  addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
  addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
  addTaskDependency("add_bc", "add_mfem_problem_operator");
  addTaskDependency("add_kernel", "add_mfem_problem_operator");
 
  // add problem composers (and operators)
  registerMooseObjectTask("add_mfem_problem_composer", MFEMProblemComposer, false);
  addTaskDependency("add_mfem_problem_operator", "add_mfem_problem_composer");
  addTaskDependency("setup_executioner", "add_mfem_problem_composer");
 
  // add SubMeshes
  registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
  addTaskDependency("add_mfem_submeshes", "create_problem_complete");
 
  // add SubMesh transfers
  appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
 
  // add FESpaces
  registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
  appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
  addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
 
  // add FESpace hierarchies (must come after fespaces so the base fespace is available)
  registerMooseObjectTask("add_mfem_fespace_hierarchies", MFEMFESpaceHierarchy, false);
  addTaskDependency("add_mfem_fespace_hierarchies", "add_mfem_fespaces");
 
  // variables must wait for hierarchies since a variable may reference a hierarchy's
  // finest level via fespace_hierarchy = ...
  addTaskDependency("add_variable", "add_mfem_fespace_hierarchies");
  addTaskDependency("add_aux_variable", "add_mfem_fespace_hierarchies");
  addTaskDependency("add_elemental_field_variable", "add_mfem_fespace_hierarchies");
  // kernels only need fespaces, not hierarchies
  addTaskDependency("add_kernel", "add_mfem_fespaces");
 
  // add complex kernels
  registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
  registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
  addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
  addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
  addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
  addTaskDependency("add_mfem_complex_bc_components", "add_bc");
 
  // set mesh FE space
  registerTask("set_mesh_fe_space", true);
  addTaskDependency("set_mesh_fe_space", "add_variable");
  addTaskDependency("set_mesh_fe_space", "init_mesh");
 
  // add solver objects.
  registerMooseObjectTask("add_mfem_solver", Moose::MFEM::SolverBase, true);
  addTaskDependency("add_mfem_solver", "add_mfem_fespace_hierarchies");
  addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
  addTaskDependency("add_mfem_solver", "add_variable");
  registerTask("resolve_mfem_solvers", true);
  addTaskDependency("resolve_mfem_solvers", "add_mfem_solver");
  addTaskDependency("init_problem", "resolve_mfem_solvers");
 
  // indicators/estimators before markers
  addTaskDependency("add_marker", "add_indicator");
#endif
 
  // Linear FV kernels fetch FVInterpolationMethod instances in their constructors. Some Physics
  // add linear FV kernels on the generic FV kernel task.
  addTaskDependency("add_interpolation_method_physics", "add_interpolation_method");
  addTaskDependency("add_fv_kernel", "add_interpolation_method_physics");
  addTaskDependency("add_linear_fv_kernel", "add_interpolation_method_physics");
  addTaskDependency("add_fv_kernel", "add_interpolation_method");
  addTaskDependency("add_linear_fv_kernel", "add_interpolation_method");
  // Linear FV kernels and BCs may register named FVGradientMethod instances in their constructors
  addTaskDependency("add_user_object", "add_gradient_method");
  addTaskDependency("add_linear_fv_kernel", "add_gradient_method");
  addTaskDependency("add_linear_fv_bc", "add_gradient_method");
 
  registerTask("parse_neml2", /*required=*/false);
  addTaskDependency("add_material", "parse_neml2");
  addTaskDependency("add_user_object", "parse_neml2");
}
 
void
registerActions(Syntax & syntax, ActionFactory & action_factory)
{
  mooseDeprecated("use registerAll instead of registerActions");
  registerActions(syntax, action_factory, {"MooseApp"});
}
 
void
registerActions(Syntax & syntax,
                ActionFactory & action_factory,
                const std::set<std::string> & obj_labels)
{
  Registry::registerActionsTo(action_factory, obj_labels);
 
  // Add these actions here so they are always executed last, without setting any dependency
  registerTask("dump_objects", false);
  registerTask("finish_input_file_output", false);
}
 
void
associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
{
  registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
  registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
 
  registerSyntax("AddActionComponentAction", "ActionComponents/*");
  registerSyntax("CombineComponentsMeshes", "ActionComponents");
 
  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
 
  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
 
  registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
 
  registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
 
  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
 
  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
 
  registerSyntax("CreateProblemAction", "Problem");
  registerSyntax("DynamicObjectRegistrationAction", "Problem");
 
  registerSyntax("SetupMeshAction", "Mesh");
  registerSyntax("SetupMeshCompleteAction", "Mesh");
  // Components should be able create a Mesh without a Mesh block
  registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
  registerSyntax("CreateDisplacedProblemAction", "Mesh");
  registerSyntax("DisplayGhostingAction", "Mesh");
  registerSyntax("AddMeshGeneratorAction", "Mesh/*");
  registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
  registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
  registerSyntax("ElementIDOutputAction", "Mesh");
  syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
 
  registerSyntax("AddFunctionAction", "Functions/*");
  syntax.registerSyntaxType("Functions/*", "FunctionName");
 
  registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
  syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
  registerSyntax("AddConvergenceAction", "Convergence/*");
  syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
 
  registerSyntax("GlobalParamsAction", "GlobalParams");
 
  registerSyntax("AddDistributionAction", "Distributions/*");
  syntax.registerSyntaxType("Distributions/*", "DistributionName");
 
  registerSyntax("AddSamplerAction", "Samplers/*");
  syntax.registerSyntaxType("Samplers/*", "SamplerName");
 
  registerSyntax("SetupDebugAction", "Debug");
  registerSyntax("SetupResidualDebugAction", "Debug");
 
  registerSyntax("AddVariableAction", "Variables/*");
  syntax.registerSyntaxType("Variables/*", "VariableName");
  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
 
  registerSyntax("AddICAction", "Variables/*/InitialCondition");
  registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
 
  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
 
  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
  registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
 
  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
 
  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
  registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
 
  registerSyntax("AddMaterialAction", "Materials/*");
  syntax.registerSyntaxType("Materials/*", "MaterialName");
 
  registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
  syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
 
  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
 
  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
 
  registerSyntax("AddReporterAction", "Reporters/*");
  syntax.registerSyntaxType("Reporters/*", "ReporterName");
 
  registerSyntax("AddPositionsAction", "Positions/*");
  syntax.registerSyntaxType("Positions/*", "PositionsName");
 
  registerSyntax("AddTimesAction", "Times/*");
  syntax.registerSyntaxType("Times/*", "TimesName");
 
  registerSyntax("AddDamperAction", "Dampers/*");
 
  registerSyntax("AddOutputAction", "Outputs/*");
  registerSyntax("CommonOutputAction", "Outputs");
  registerSyntax("MaterialOutputAction", "Outputs");
  registerSyntax("AutoCheckpointAction", "Outputs");
  syntax.registerSyntaxType("Outputs/*", "OutputName");
 
  // Note: Preconditioner Actions will be built by this setup action
  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
 
  registerSyntax("CreateExecutionerAction", "Executioner");
  registerSyntax("ReadExecutorParamsAction", "Executors/*");
 
  registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
  registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
  registerSyntaxTask(
      "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
  registerSyntaxTask(
      "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
  registerSyntaxTask(
      "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
  syntax.registerSyntaxType("Executors/*", "ExecutorName");
 
  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
#ifdef LIBMESH_ENABLE_AMR
  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
#endif
 
  registerSyntax("PartitionerAction", "Mesh/Partitioner");
 
  registerSyntax("AddDiracKernelAction", "DiracKernels/*");
 
  registerSyntax("AddDGKernelAction", "DGKernels/*");
  registerSyntax("AddFVKernelAction", "FVKernels/*");
  registerSyntax("AddFVBCAction", "FVBCs/*");
  registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
  registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
  registerSyntax("CheckFVBCAction", "FVBCs");
 
  registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
 
  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
 
  registerSyntax("AddConstraintAction", "Constraints/*");
 
  registerSyntax("AddControlAction", "Controls/*");
  registerSyntax("AddChainControlAction", "ChainControls/*");
  registerSyntax("AddBoundAction", "Bounds/*");
  registerSyntax("AddBoundsVectorsAction", "Bounds");
 
  // UserObject and some derived classes
  registerSyntax("AddUserObjectAction", "UserObjects/*");
  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
 
  registerSyntax("AddCorrectorAction", "Correctors/*");
  syntax.registerSyntaxType("Correctors/*", "UserObjectName");
 
  registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
  syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
 
  registerSyntax("AddNodalNormalsAction", "NodalNormals");
 
  // FVInterpolationMethods
  registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
  syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
 
  // FVGradientMethods
  registerSyntax("AddFVGradientMethodAction", "FVGradientMethods/*");
  syntax.registerSyntaxType("FVGradientMethods/*", "GradientMethodName");
 
  // Indicator
  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
 
  // Marker
  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
 
  // New Adaptivity System
  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
 
  // Deprecated Block
  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
 
  // Multi Apps
  registerSyntax("AddMultiAppAction", "MultiApps/*");
  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
 
  // Transfers
  registerSyntax("AddTransferAction", "Transfers/*");
 
  // Material derivative test
  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
 
  registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
 
  // Application Block System
  registerSyntax("CreateApplicationBlockAction", "Application");
 
#ifdef MOOSE_MFEM_ENABLED
  registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
  registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
  registerSyntaxTask(
      "AddMFEMFESpaceHierarchyAction", "FESpaceHierarchies/*", "add_mfem_fespace_hierarchies");
  registerSyntaxTask(
      "AddMFEMComplexKernelComponentAction", "Kernels/*/*", "add_mfem_complex_kernel_components");
  registerSyntaxTask(
      "AddMFEMComplexBCComponentAction", "BCs/*/*", "add_mfem_complex_bc_components");
  registerSyntaxTask("AddMFEMSolverAction", "Solvers/*", "add_mfem_solver");
  syntax.registerSyntaxType("Solvers/*", "MFEMSolverName");
  registerSyntaxTask(
      "AddMFEMProblemComposerAction", "ProblemComposers/*", "add_mfem_problem_composer");
#endif
 
  registerSyntax("NEML2ActionCommon", "NEML2");
  registerSyntax("NEML2Action", "NEML2/*");
 
  addActionTypes(syntax);
}
 
void
associateSyntax(Syntax & syntax, ActionFactory & action_factory)
{
  associateSyntaxInner(syntax, action_factory);
  registerActions(syntax, action_factory);
}
 
void
setSolverDefaults(FEProblemBase & problem)
{
  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
  Moose::PetscSupport::petscSetDefaults(problem);
}
 
MPI_Comm
swapLibMeshComm(MPI_Comm new_comm)
{
  MPI_Comm old_comm = PETSC_COMM_WORLD;
  PETSC_COMM_WORLD = new_comm;
  return old_comm;
}
 
static bool _color_console = isatty(fileno(stdout));
 
bool
colorConsole()
{
  return _color_console;
}
 
bool
setColorConsole(bool use_color, bool force)
{
  _color_console = (isatty(fileno(stdout)) || force) && use_color;
  return _color_console;
}
 
ScopedThrowOnError::ScopedThrowOnError(const bool throw_on_error)
  : _throw_on_error_before(Moose::_throw_on_error)
{
  mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
  Moose::_throw_on_error = throw_on_error;
}
 
ScopedThrowOnError::ScopedThrowOnError() : ScopedThrowOnError(true) {}
 
ScopedThrowOnError::~ScopedThrowOnError() { Moose::_throw_on_error = _throw_on_error_before; }
 
ScopedDeprecatedIsError::ScopedDeprecatedIsError(const bool deprecated_is_error)
  : _deprecated_is_error_before(Moose::_deprecated_is_error)
{
  mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
  Moose::_deprecated_is_error = deprecated_is_error;
}
 
ScopedDeprecatedIsError::ScopedDeprecatedIsError() : ScopedDeprecatedIsError(true) {}
 
ScopedDeprecatedIsError::~ScopedDeprecatedIsError()
{
  Moose::_deprecated_is_error = _deprecated_is_error_before;
}
 
std::string
hitMessagePrefix(const hit::Node & node)
{
  // Strip meaningless line and column number for CLI args
  if (node.filename() == "CLI_ARGS")
    return "CLI_ARGS:\n";
  // If using the root node, don't add line info
  if (node.isRoot())
    return node.filename() + ":\n";
  return node.fileLocation() + ":\n";
}
 
bool _warnings_are_errors = false;
bool _deprecated_is_error = false;
bool _throw_on_error = false;
bool _throw_on_warning = false;
volatile std::sig_atomic_t interrupt_signal_number = 0;
bool show_multiple = false;
 
} // namespace Moose