https://mooseframework.inl.gov
Moose.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "libmesh/petsc_macro.h"
11 #include "libmesh/libmesh_config.h"
12 
13 #include "Moose.h"
14 #include "MooseApp.h"
15 
16 #include "ActionWarehouse.h"
17 #include "ActionFactory.h"
18 #include "AuxiliarySystem.h"
19 #include "Factory.h"
20 #include "PetscSupport.h"
21 #include "Syntax.h"
22 #include "MooseSyntax.h"
23 #include "ExecFlagRegistry.h"
24 
25 #include "hit/parse.h"
26 
27 #include <unistd.h>
28 
29 const ExecFlagType EXEC_NONE = registerDefaultExecFlag("NONE");
30 const ExecFlagType EXEC_INITIAL = registerDefaultExecFlag("INITIAL");
31 const ExecFlagType EXEC_LINEAR = registerDefaultExecFlag("LINEAR");
32 const ExecFlagType EXEC_LINEAR_CONVERGENCE = registerDefaultExecFlag("LINEAR_CONVERGENCE");
33 const ExecFlagType EXEC_NONLINEAR = registerDefaultExecFlag("NONLINEAR");
34 const ExecFlagType EXEC_NONLINEAR_CONVERGENCE = registerDefaultExecFlag("NONLINEAR_CONVERGENCE");
35 const ExecFlagType EXEC_POSTCHECK = registerDefaultExecFlag("POSTCHECK");
36 const ExecFlagType EXEC_TIMESTEP_END = registerDefaultExecFlag("TIMESTEP_END");
37 const ExecFlagType EXEC_TIMESTEP_BEGIN = registerDefaultExecFlag("TIMESTEP_BEGIN");
39  registerExecFlag("MULTIAPP_FIXED_POINT_ITERATION_END");
41  registerDefaultExecFlag("MULTIAPP_FIXED_POINT_END");
43  registerDefaultExecFlag("MULTIAPP_FIXED_POINT_BEGIN");
45  registerDefaultExecFlag("MULTIAPP_FIXED_POINT_CONVERGENCE");
46 const ExecFlagType EXEC_FINAL = registerDefaultExecFlag("FINAL");
47 const ExecFlagType EXEC_FORCED = registerExecFlag("FORCED");
48 const ExecFlagType EXEC_FAILED = registerExecFlag("FAILED");
49 const ExecFlagType EXEC_CUSTOM = registerDefaultExecFlag("CUSTOM");
50 const ExecFlagType EXEC_SUBDOMAIN = registerExecFlag("SUBDOMAIN");
51 const ExecFlagType EXEC_ALWAYS = registerExecFlag("ALWAYS");
52 const ExecFlagType EXEC_PRE_DISPLACE = registerExecFlag("PRE_DISPLACE");
53 const ExecFlagType EXEC_SAME_AS_MULTIAPP = registerExecFlag("SAME_AS_MULTIAPP");
54 const ExecFlagType EXEC_PRE_MULTIAPP_SETUP = registerExecFlag("PRE_MULTIAPP_SETUP");
55 const ExecFlagType EXEC_TRANSFER = registerExecFlag("TRANSFER");
56 const ExecFlagType EXEC_PRE_KERNELS = registerExecFlag("PRE_KERNELS");
57 #ifdef LIBMESH_ENABLE_AMR
58 const ExecFlagType EXEC_POST_ADAPTIVITY = registerExecFlag("POST_ADAPTIVITY");
59 #endif
60 
61 namespace Moose
62 {
63 
64 void associateSyntaxInner(Syntax & syntax, ActionFactory & action_factory);
65 
66 void
68 {
69  registerObjects(f, {"MooseApp"});
70  associateSyntaxInner(s, af);
71  registerActions(s, af, {"MooseApp"});
72  registerAppDataFilePath("moose");
73  registerRepository("moose", "github.com/idaholab/moose");
74 
75  // Citation emitted by the --citations command-line option: the current framework paper is tied to
76  // "MooseApp" (so it is cited whenever a MooseApp object is used, and apps composed of MooseApp
77  // inherit it), and modules register their own app citations (via Registry::addAppCitation) which
78  // are cited only when one of their objects is actually used. PETSc and its sub-packages register
79  // their own citations, which --citations emits through PETSc.
80  Registry::addAppCitation("MooseApp",
81  "harbour2025moose",
82  R"(@article{harbour2025moose,
83  title = {4.0 {MOOSE}: Enabling massively parallel Multiphysics simulation},
84  journal = {{SoftwareX}},
85  volume = {31},
86  pages = {102264},
87  year = {2025},
88  issn = {2352-7110},
89  doi = {https://doi.org/10.1016/j.softx.2025.102264},
90  url = {https://www.sciencedirect.com/science/article/pii/S2352711025002316},
91  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},
92 })");
93 }
94 
95 void
96 registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
97 {
98  Registry::registerObjectsTo(factory, obj_labels);
99 }
100 
101 void
103 {
116  // clang-format off
117  /**************************/
118  /**** Register Actions ****/
119  /**************************/
120  registerMooseObjectTask("create_problem", Problem, false);
121  registerMooseObjectTask("setup_executioner", Executioner, false);
122  registerMooseObjectTask("read_executor", Executor, false);
123  registerTask("add_executor", true);
124 
125  // TODO Organize these somewhere
126  registerTask("init_physics", false);
127  registerTask("init_component_physics", false);
128  registerTask("meta_action_component", false);
129  registerTask("setup_component", false);
130  // 'list_component' is used to retrieve ActionComponents for the syntax JSON
131  registerTask("list_component", false);
132 
133  // This task does not construct an object, but it needs all of the parameters that
134  // would normally be used to construct an object.
135  registerMooseObjectTask("determine_system_type", Executioner, true);
136 
137  registerMooseObjectTask("setup_mesh", MooseMesh, false);
138  registerMooseObjectTask("set_mesh_base", MooseMesh, false);
139  registerMooseObjectTask("init_mesh", MooseMesh, false);
140  registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
141  registerTask("create_added_mesh_generators", true);
142  registerMooseObjectTask("append_mesh_generator", MeshGenerator, false);
143 
144  registerMooseObjectTask("add_kernel", Kernel, false);
145  appendMooseObjectTask ("add_kernel", EigenKernel);
146  appendMooseObjectTask ("add_kernel", VectorKernel);
147  appendMooseObjectTask ("add_kernel", ArrayKernel);
148  appendMooseObjectTask ("add_kernel", ADArrayKernel);
149 
150  registerMooseObjectTask("add_variable", MooseVariableBase, false);
151  registerMooseObjectTask("add_aux_variable", MooseVariableBase, false);
152  registerMooseObjectTask("add_elemental_field_variable", MooseVariableBase, false);
153  registerMooseObjectTask("add_variables_physics", MooseVariableBase, false);
154 
155  registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
156 
157  registerMooseObjectTask("add_functor_material", FunctorMaterial, false);
158  registerMooseObjectTask("add_material", MaterialBase, false);
159  appendDeprecatedMooseObjectTask("add_material", FunctorMaterial);
160  registerMooseObjectTask("add_materials_physics", FunctorMaterial, false);
161  appendMooseObjectTask ("add_materials_physics", MaterialBase);
162 
163  registerMooseObjectTask("add_bc", BoundaryCondition, false);
164 
165  registerMooseObjectTask("add_function", Function, false);
166 
167  registerMooseObjectTask("add_distribution", Distribution, false);
168  registerMooseObjectTask("add_sampler", Sampler, false);
169 
170  registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
171  appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
172  appendMooseObjectTask ("add_aux_kernel", ArrayAuxKernel);
173 
174  registerMooseObjectTask("add_bound", Bounds, false);
175 
176  registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
177  registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
178  registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
179  appendMooseObjectTask ("add_dirac_kernel", VectorDiracKernel);
180  registerMooseObjectTask("add_dg_kernel", DGKernel, false);
181  registerMooseObjectTask("add_fv_kernel", FVKernel, false);
182  registerMooseObjectTask("add_interpolation_method", FVInterpolationMethod, false);
183  registerMooseObjectTask("add_linear_fv_kernel", LinearFVKernel, false);
184  registerMooseObjectTask("add_fv_bc", FVBoundaryCondition, false);
185  registerMooseObjectTask("add_linear_fv_bc", LinearFVBoundaryCondition, false);
186  registerMooseObjectTask("add_fv_ik", FVInterfaceKernel, false);
187  registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
188  appendMooseObjectTask ("add_interface_kernel", VectorInterfaceKernel);
189  registerMooseObjectTask("add_constraint", Constraint, false);
190  registerMooseObjectTask("add_hybridized_kernel", HDGKernel, false);
191  registerMooseObjectTask("add_hybridized_integrated_bc", HDGIntegratedBC, false);
192 
193  registerMooseObjectTask("add_ic", InitialCondition, false);
194  appendMooseObjectTask ("add_ic", ScalarInitialCondition);
195  registerMooseObjectTask("add_fv_ic", FVInitialCondition, false);
196  registerMooseObjectTask("add_ics_physics", InitialCondition, false);
197  appendMooseObjectTask ("add_ics_physics", FVInitialCondition);
198  appendMooseObjectTask ("add_ics_physics", ScalarInitialCondition);
199 
200  registerMooseObjectTask("add_damper", Damper, false);
201  registerMooseObjectTask("setup_predictor", Predictor, false);
202  registerMooseObjectTask("add_time_steppers", TimeStepper, false);
203  registerMooseObjectTask("add_time_stepper", TimeStepper, false);
204  registerTask ("compose_time_stepper", true);
205  registerMooseObjectTask("setup_time_integrators", TimeIntegrator, false);
206  registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
207  registerMooseObjectTask("add_convergence", Convergence, false);
208 
209  registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
210  registerMooseObjectTask("add_field_split", Split, false);
211 
212  registerMooseObjectTask("add_mesh_division", MeshDivision, false);
213  registerMooseObjectTask("add_user_object", UserObject, false);
214  appendMooseObjectTask ("add_user_object", Postprocessor);
215 
216  appendDeprecatedMooseObjectTask("add_user_object", Corrector);
217  registerMooseObjectTask("add_corrector", Corrector, false);
218  appendDeprecatedMooseObjectTask("add_user_object", MeshModifier);
219  registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
220 
221  registerMooseObjectTask("add_postprocessor", Postprocessor, false);
222  registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
223  registerMooseObjectTask("add_reporter", Reporter, false);
224 
225  registerMooseObjectTask("add_positions", Positions, false);
226  registerMooseObjectTask("add_times", Times, false);
227 
228  registerMooseObjectTask("add_indicator", Indicator, false);
229  registerMooseObjectTask("add_marker", Marker, false);
230 
231  registerMooseObjectTask("add_multi_app", MultiApp, false);
232  registerMooseObjectTask("add_transfer", Transfer, false);
233 
234  registerMooseObjectTask("add_output", Output, false);
235 
236  registerMooseObjectTask("add_control", Control, false);
237  registerMooseObjectTask("add_chain_control", ChainControl, false);
238  registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
239 
240  // clang-format on
241 
242  registerTask("dynamic_object_registration", false);
243  registerTask("common_output", true);
244  registerTask("setup_recover_file_base", true);
245  registerTask("recover_meta_data", true);
246 
247  registerTask("add_bounds_vectors", false);
248  registerTask("add_periodic_bc", false);
249  registerTask("add_aux_variable", false);
250  registerTask("add_external_aux_variables", true);
251  registerTask("add_variable", false);
252  registerTask("add_mortar_variable", false);
253 
254  registerTask("execute_mesh_generators", true);
255  registerTask("uniform_refine_mesh", false);
256  registerTask("prepare_mesh", false);
257  registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
258  registerTask("setup_mesh_complete", true); // calls prepare
259  registerTask("post_mesh_prepared", false);
260  registerTask("add_geometric_rm", false);
261  registerTask("attach_geometric_rm", true);
262  registerTask("attach_geometric_rm_final", true);
263 
264  registerTask("init_displaced_problem", false);
265 
266  registerTask("add_algebraic_rm", false);
267  registerTask("attach_algebraic_rm", true);
268  registerTask("add_coupling_rm", false);
269  registerTask("attach_coupling_rm", true);
270  registerTask("init_problem", true);
271  registerTask("check_copy_nodal_vars", true);
272  registerTask("copy_nodal_vars", true);
273  registerTask("copy_nodal_aux_vars", true);
274  registerTask("copy_vars_physics", false);
275  registerTask("setup_postprocessor_data", false);
276  registerTask("setup_time_steppers", true);
277 
278  registerTask("setup_dampers", true);
279  registerTask("check_integrity", true);
280  registerTask("resolve_optional_materials", true);
281  registerTask("check_integrity_early", true);
282  registerTask("check_integrity_early_physics", false);
283  registerTask("setup_quadrature", true);
284  registerTask("create_tagged_matrices", true);
285 
286  registerTask("mesh_modifiers", false);
287 
289  registerTask("no_action", false); // Used for Empty Action placeholders
290  registerTask("set_global_params", false);
291  registerTask("setup_adaptivity", false);
292  registerTask("meta_action", false);
293  registerTask("setup_residual_debug", false);
294  registerTask("setup_oversampling", false);
295  registerTask("deprecated_block", false);
296  registerTask("set_adaptivity_options", false);
297  registerTask("add_mortar_interface", false);
298  registerTask("coupling_functor_check", true);
299  registerTask("add_master_action_material", false);
300  registerTask("setup_projected_properties", false);
301  registerTask("create_application_block", false);
302 
303  // Dummy Actions (useful for sync points in the dependencies)
304  registerTask("setup_function_complete", false);
305  registerTask("setup_variable_complete", false);
306  registerTask("setup_executioner_complete", false);
307  registerTask("ready_to_init", true);
308 
309  // Output related actions
310  registerTask("add_output_aux_variables", true);
311  registerTask("check_output", true);
312  registerTask("declare_late_reporters", true);
313 
314  registerTask("create_problem_default", true);
315  registerTask("create_problem_custom", false);
316  registerTask("create_problem_complete", false);
317 
318  registerTask("add_default_nonlinear_convergence", true);
319  registerTask("add_default_multiapp_fixed_point_convergence", true);
320  registerTask("add_default_steady_state_convergence", true);
321 
322  registerTask("chain_control_setup", true);
323  registerTask("start_webservercontrol", true);
324 
325  // Action for setting up the signal-based checkpoint
326  registerTask("auto_checkpoint_action", true);
327  /**************************/
328  /****** Dependencies ******/
329  /**************************/
340  // clang-format off
341  syntax.addDependencySets("(meta_action)"
342  "(meta_action_component)"
343  "(dynamic_object_registration)"
344  "(common_output)"
345  "(set_global_params)"
346  "(setup_recover_file_base)"
347  "(check_copy_nodal_vars)"
348  "(setup_mesh)"
349  "(add_geometric_rm)"
350  "(add_partitioner)"
351  "(add_mesh_generator)"
352  "(create_added_mesh_generators)"
353  "(append_mesh_generator)"
354  "(execute_mesh_generators)"
355  "(recover_meta_data)"
356  "(set_mesh_base)"
357  "(attach_geometric_rm)"
358  "(init_mesh)"
359  "(prepare_mesh)"
360  "(add_mortar_interface)"
361  "(uniform_refine_mesh)"
362  "(setup_mesh_complete)"
363  "(post_mesh_prepared)"
364  "(determine_system_type)"
365  "(create_problem)"
366  "(create_problem_custom)"
367  "(create_problem_default)"
368  "(create_problem_complete)"
369  "(init_displaced_problem)" // Problem must be init-ed before we start adding functors
370  "(add_function)" // Functions can depend on scalar variables & PPs, but this dependence can be
371  // added on initialSetup() rather than construction
372  "(init_component_physics)" // components must add their blocks to physics before init_physics
373  "(init_physics)"
374  "(setup_postprocessor_data)"
375  "(setup_time_integrator, setup_time_integrators)"
376  "(setup_executioner)"
377  "(setup_executioner_complete)"
378  "(setup_component)" // no particular reason for that placement
379  "(read_executor)"
380  "(add_executor)"
381  "(check_integrity_early)"
382  "(setup_predictor)"
383  "(add_aux_variable, add_variable, add_elemental_field_variable,"
384  " add_external_aux_variables)"
385  "(add_variables_physics)" // physics can skip adding variables if they already exist
386  "(add_mortar_variable)"
387  "(setup_variable_complete)"
388  "(check_integrity_early_physics)" // checks that systems and variables are consistent
389  "(setup_quadrature)"
390  "(add_convergence)"
391  "(add_default_nonlinear_convergence,"
392  " add_default_multiapp_fixed_point_convergence,"
393  " add_default_steady_state_convergence)"
394  "(add_positions)"
395  "(add_periodic_bc)"
396  "(add_user_object, add_corrector, add_mesh_modifier)"
397  "(add_field_split)" // split objects required before field split preconditioner itself
398  "(add_preconditioning)" // preconditioner may introduce objects such as static condensation which influence the underlying types of tagged matrices
399  "(create_tagged_matrices)"
400  "(add_distribution)"
401  "(add_sampler)"
402  "(setup_function_complete)"
403  "(setup_adaptivity)"
404  "(set_adaptivity_options)"
405  "(add_ic, add_fv_ic)"
406  "(add_ics_physics)" // physics can skip adding initial conditions if they already exist
407  "(add_constraint)"
408  "(add_times)"
409  "(add_time_stepper, add_time_steppers)"
410  "(compose_time_stepper)"
411  "(setup_time_steppers)"
412  "(ready_to_init)"
413  "(setup_dampers)"
414  "(setup_residual_debug)"
415  "(add_bounds_vectors)"
416  "(add_mesh_division)" // NearestPositionsDivision uses a Positions
417  "(add_multi_app)"
418  "(add_transfer)"
419  "(copy_nodal_vars, copy_nodal_aux_vars, copy_vars_physics)"
420  "(add_material)"
421  "(add_master_action_material)"
422  "(add_functor_material)"
423  "(add_materials_physics)"
424  "(setup_projected_properties)"
425  "(add_output_aux_variables)"
426  "(add_output)"
427  "(auto_checkpoint_action)"
428  "(add_postprocessor)"
429  "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
430  // to be after material objects are created.
431  "(add_reporter)"
432  "(declare_late_reporters)"
433  "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
434  " add_nodal_kernel, add_dg_kernel, add_fv_kernel, add_interpolation_method,"
435  " add_linear_fv_kernel,"
436  " add_fv_bc, add_linear_fv_bc, add_fv_ik, add_interface_kernel,"
437  " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker,"
438  " add_bound, add_hybridized_kernel, add_hybridized_integrated_bc)"
439  "(resolve_optional_materials)"
440  "(add_algebraic_rm)"
441  "(add_coupling_rm)"
442  "(attach_geometric_rm_final)"
443  "(attach_algebraic_rm)"
444  "(attach_coupling_rm)"
445  "(coupling_functor_check)"
446  "(delete_remote_elements_after_late_geometric_ghosting)"
447  "(init_problem)"
448  "(add_control, add_chain_control)"
449  "(chain_control_setup)"
450  "(start_webservercontrol)"
451  "(check_output)"
452  "(check_integrity)"
453  "(create_application_block)");
454  // clang-format on
455 
456 #ifdef MOOSE_MFEM_ENABLED
457  registerTask("add_mfem_problem_operator", true);
458  addTaskDependency("add_mfem_problem_operator", "init_mesh");
459  addTaskDependency("add_variable", "add_mfem_problem_operator");
460  addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
461  addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
462  addTaskDependency("add_bc", "add_mfem_problem_operator");
463  addTaskDependency("add_kernel", "add_mfem_problem_operator");
464 
465  // add SubMeshes
466  registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
467  addTaskDependency("add_mfem_submeshes", "create_problem_complete");
468 
469  // add SubMesh transfers
470  appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
471 
472  // add FESpaces
473  registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
474  appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
475  addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
476  addTaskDependency("add_variable", "add_mfem_fespaces");
477  addTaskDependency("add_aux_variable", "add_mfem_fespaces");
478  addTaskDependency("add_elemental_field_variable", "add_mfem_fespaces");
479  addTaskDependency("add_kernel", "add_mfem_fespaces");
480 
481  // add complex kernels
482  registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
483  registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
484  addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
485  addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
486  addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
487  addTaskDependency("add_mfem_complex_bc_components", "add_bc");
488 
489  // set mesh FE space
490  registerTask("set_mesh_fe_space", true);
491  addTaskDependency("set_mesh_fe_space", "add_variable");
492  addTaskDependency("set_mesh_fe_space", "init_mesh");
493 
494  // add preconditioning.
495  registerMooseObjectTask("add_mfem_preconditioner", Moose::MFEM::SolverBase, false);
496  addTaskDependency("add_mfem_preconditioner", "add_mfem_problem_operator");
497  addTaskDependency("add_mfem_preconditioner", "add_variable");
498 
499  // add solver objects.
500  registerMooseObjectTask("add_mfem_solver", Moose::MFEM::SolverBase, true);
501  addTaskDependency("add_mfem_solver", "add_mfem_preconditioner");
502  addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
503 #endif
504 
505  // Linear FV kernels fetch FVInterpolationMethod instances in their constructors
506  addTaskDependency("add_linear_fv_kernel", "add_interpolation_method");
507 
508  registerTask("parse_neml2", /*required=*/false);
509  addTaskDependency("add_material", "parse_neml2");
510  addTaskDependency("add_user_object", "parse_neml2");
511 }
512 
541 void
542 registerActions(Syntax & syntax, ActionFactory & action_factory)
543 {
544  mooseDeprecated("use registerAll instead of registerActions");
545  registerActions(syntax, action_factory, {"MooseApp"});
546 }
547 
548 void
550  ActionFactory & action_factory,
551  const std::set<std::string> & obj_labels)
552 {
553  Registry::registerActionsTo(action_factory, obj_labels);
554 
555  // Add these actions here so they are always executed last, without setting any dependency
556  registerTask("dump_objects", false);
557  registerTask("finish_input_file_output", false);
558 }
559 
560 void
561 associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
562 {
568  registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
569  registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
570 
571  registerSyntax("AddActionComponentAction", "ActionComponents/*");
572  registerSyntax("CombineComponentsMeshes", "ActionComponents");
573 
574  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
575  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
576  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
577  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
578 
579  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
580  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
581  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
582 
583  registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
584 
585  registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
586 
587  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
588  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
589 
590  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
591 
592  registerSyntax("CreateProblemAction", "Problem");
593  registerSyntax("DynamicObjectRegistrationAction", "Problem");
594 
595  registerSyntax("SetupMeshAction", "Mesh");
596  registerSyntax("SetupMeshCompleteAction", "Mesh");
597  // Components should be able create a Mesh without a Mesh block
598  registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
599  registerSyntax("CreateDisplacedProblemAction", "Mesh");
600  registerSyntax("DisplayGhostingAction", "Mesh");
601  registerSyntax("AddMeshGeneratorAction", "Mesh/*");
602  registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
603  registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
604  registerSyntax("ElementIDOutputAction", "Mesh");
605  syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
606 
607  registerSyntax("AddFunctionAction", "Functions/*");
608  syntax.registerSyntaxType("Functions/*", "FunctionName");
609 
610  registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
611  syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
612  registerSyntax("AddConvergenceAction", "Convergence/*");
613  syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
614 
615  registerSyntax("GlobalParamsAction", "GlobalParams");
616 
617  registerSyntax("AddDistributionAction", "Distributions/*");
618  syntax.registerSyntaxType("Distributions/*", "DistributionName");
619 
620  registerSyntax("AddSamplerAction", "Samplers/*");
621  syntax.registerSyntaxType("Samplers/*", "SamplerName");
622 
623  registerSyntax("SetupDebugAction", "Debug");
624  registerSyntax("SetupResidualDebugAction", "Debug");
625 
627  registerSyntax("AddVariableAction", "Variables/*");
628  syntax.registerSyntaxType("Variables/*", "VariableName");
629  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
630 
631  registerSyntax("AddICAction", "Variables/*/InitialCondition");
632  registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
633 
634  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
635  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
636  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
637 
638  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
639  registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
640 
641  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
642  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
643 
644  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
645  registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
646 
647  registerSyntax("AddMaterialAction", "Materials/*");
648  syntax.registerSyntaxType("Materials/*", "MaterialName");
649 
650  registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
651  syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
652 
653  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
654  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
655  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
656 
657  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
658  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
659 
660  registerSyntax("AddReporterAction", "Reporters/*");
661  syntax.registerSyntaxType("Reporters/*", "ReporterName");
662 
663  registerSyntax("AddPositionsAction", "Positions/*");
664  syntax.registerSyntaxType("Positions/*", "PositionsName");
665 
666  registerSyntax("AddTimesAction", "Times/*");
667  syntax.registerSyntaxType("Times/*", "TimesName");
668 
669  registerSyntax("AddDamperAction", "Dampers/*");
670 
671  registerSyntax("AddOutputAction", "Outputs/*");
672  registerSyntax("CommonOutputAction", "Outputs");
673  registerSyntax("MaterialOutputAction", "Outputs");
674  registerSyntax("AutoCheckpointAction", "Outputs");
675  syntax.registerSyntaxType("Outputs/*", "OutputName");
676 
677  // Note: Preconditioner Actions will be built by this setup action
678  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
679  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
680 
681  registerSyntax("CreateExecutionerAction", "Executioner");
682  registerSyntax("ReadExecutorParamsAction", "Executors/*");
683 
684  registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
685  registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
686  registerSyntaxTask(
687  "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
688  registerSyntaxTask(
689  "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
690  registerSyntaxTask(
691  "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
692  syntax.registerSyntaxType("Executors/*", "ExecutorName");
693 
694  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
695  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
696 #ifdef LIBMESH_ENABLE_AMR
697  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
698 #endif
699 
700  registerSyntax("PartitionerAction", "Mesh/Partitioner");
701 
702  registerSyntax("AddDiracKernelAction", "DiracKernels/*");
703 
704  registerSyntax("AddDGKernelAction", "DGKernels/*");
705  registerSyntax("AddFVKernelAction", "FVKernels/*");
706  registerSyntax("AddFVBCAction", "FVBCs/*");
707  registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
708  registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
709  registerSyntax("CheckFVBCAction", "FVBCs");
710 
711  registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
712 
713  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
714 
715  registerSyntax("AddConstraintAction", "Constraints/*");
716 
717  registerSyntax("AddControlAction", "Controls/*");
718  registerSyntax("AddChainControlAction", "ChainControls/*");
719  registerSyntax("AddBoundAction", "Bounds/*");
720  registerSyntax("AddBoundsVectorsAction", "Bounds");
721 
722  // UserObject and some derived classes
723  registerSyntax("AddUserObjectAction", "UserObjects/*");
724  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
725 
726  registerSyntax("AddCorrectorAction", "Correctors/*");
727  syntax.registerSyntaxType("Correctors/*", "UserObjectName");
728 
729  registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
730  syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
731 
732  registerSyntax("AddNodalNormalsAction", "NodalNormals");
733 
734  // FVInterpolationMethods
735  registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
736  syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
737 
738  // Indicator
739  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
740  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
741  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
742 
743  // Marker
744  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
745  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
746  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
747 
748  // New Adaptivity System
749  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
750 
751  // Deprecated Block
752  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
753 
754  // Multi Apps
755  registerSyntax("AddMultiAppAction", "MultiApps/*");
756  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
757 
758  // Transfers
759  registerSyntax("AddTransferAction", "Transfers/*");
760 
761  // Material derivative test
762  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
763  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
764 
765  registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
766 
767  // Application Block System
768  registerSyntax("CreateApplicationBlockAction", "Application");
769 
770 #ifdef MOOSE_MFEM_ENABLED
771  registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
772  registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
773  registerSyntaxTask(
774  "AddMFEMComplexKernelComponentAction", "Kernels/*/*", "add_mfem_complex_kernel_components");
775  registerSyntaxTask(
776  "AddMFEMComplexBCComponentAction", "BCs/*/*", "add_mfem_complex_bc_components");
777  registerSyntaxTask("AddMFEMPreconditionerAction", "Preconditioner/*", "add_mfem_preconditioner");
778  registerSyntaxTask("AddMFEMSolverAction", "Solvers/*", "add_mfem_solver");
779  syntax.registerSyntaxType("Solvers/*", "MFEMSolverName");
780 #endif
781 
782  registerSyntax("NEML2ActionCommon", "NEML2");
783  registerSyntax("NEML2Action", "NEML2/*");
784 
785  addActionTypes(syntax);
786 }
787 
788 void
789 associateSyntax(Syntax & syntax, ActionFactory & action_factory)
790 {
791  associateSyntaxInner(syntax, action_factory);
792  registerActions(syntax, action_factory);
793 }
794 
795 void
797 {
798  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
800 }
801 
802 MPI_Comm
803 swapLibMeshComm(MPI_Comm new_comm)
804 {
805  MPI_Comm old_comm = PETSC_COMM_WORLD;
806  PETSC_COMM_WORLD = new_comm;
807  return old_comm;
808 }
809 
810 static bool _color_console = isatty(fileno(stdout));
811 
812 bool
814 {
815  return _color_console;
816 }
817 
818 bool
819 setColorConsole(bool use_color, bool force)
820 {
821  _color_console = (isatty(fileno(stdout)) || force) && use_color;
822  return _color_console;
823 }
824 
825 ScopedThrowOnError::ScopedThrowOnError(const bool throw_on_error)
826  : _throw_on_error_before(Moose::_throw_on_error)
827 {
828  mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
829  Moose::_throw_on_error = throw_on_error;
830 }
831 
833 
835 
837  : _deprecated_is_error_before(Moose::_deprecated_is_error)
838 {
839  mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
840  Moose::_deprecated_is_error = deprecated_is_error;
841 }
842 
844 
846 {
848 }
849 
850 std::string
851 hitMessagePrefix(const hit::Node & node)
852 {
853  // Strip meaningless line and column number for CLI args
854  if (node.filename() == "CLI_ARGS")
855  return "CLI_ARGS:\n";
856  // If using the root node, don't add line info
857  if (node.isRoot())
858  return node.filename() + ":\n";
859  return node.fileLocation() + ":\n";
860 }
861 
862 bool _warnings_are_errors = false;
863 bool _deprecated_is_error = false;
864 bool _throw_on_error = false;
865 bool _throw_on_warning = false;
867 bool show_multiple = false;
868 
869 } // namespace Moose
const ExecFlagType EXEC_LINEAR_CONVERGENCE
Definition: Moose.C:32
Base class for function objects.
Definition: Function.h:29
A kernel for hybridized finite element formulations.
Definition: HDGKernel.h:17
Base class for boundary conditions for linear FV systems.
bool colorConsole()
Returns whether Console coloring is turned on (default: true).
Definition: Moose.C:813
Base class for split-based preconditioners.
Definition: Split.h:25
Base class for finite volume kernels that contribute to a linear systems.
MPI_Comm swapLibMeshComm(MPI_Comm new_comm)
Swap the libMesh MPI communicator out for ours.
Definition: Moose.C:803
const ExecFlagType EXEC_PRE_KERNELS
Definition: Moose.C:56
Generic factory class for build all sorts of objects.
Definition: Factory.h:28
void setSolverDefaults(FEProblemBase &problem)
Definition: Moose.C:796
This is the base class for Samplers as used within the Stochastic Tools module.
Definition: Sampler.h:45
Base class for predictors.
Definition: Predictor.h:28
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
Definition: PetscSupport.C:598
Base class for creating new types of boundary conditions.
bool _warnings_are_errors
Variable to toggle any warning into an error (includes deprecated code warnings)
Definition: Moose.C:862
~ScopedDeprecatedIsError()
Destructor, which sets Moose::_deprecated_is_error to what it was upon construction.
Definition: Moose.C:845
InterfaceKernel and VectorInterfaceKernel is responsible for interfacing physics across subdomains...
static void addAppCitation(const std::string &app_name, const std::string &key, const std::string &bibtex)
Register a citation (the full BibTeX bibtex text, identified by key) tied to the app app_name; emitte...
Definition: Registry.C:198
void registerActions(Syntax &syntax, ActionFactory &action_factory)
Multiple Action class can be associated with a single input file section, in which case all associate...
Definition: Moose.C:542
This is a template class that implements the workhorse compute and computeNodal methods.
Base class for all Constraint types.
Definition: Constraint.h:19
const ExecFlagType EXEC_PRE_MULTIAPP_SETUP
Definition: Moose.C:54
Positions objects are under the hood Reporters.
Definition: Positions.h:20
Class that hold the whole problem being solved.
Definition: Problem.h:19
Definition: Marker.h:41
const bool _throw_on_error_before
The value of Moose::_throw_on_error at construction.
Definition: Moose.h:317
ScopedDeprecatedIsError()
Default constructor, which sets Moose::_deprecated_is_error = true.
Definition: Moose.C:843
Base class for time stepping.
Definition: TimeStepper.h:22
Times objects are under the hood Reporters, but limited to a vector of Real.
Definition: Times.h:18
void associateSyntax(Syntax &syntax, ActionFactory &action_factory)
Definition: Moose.C:789
const bool _deprecated_is_error_before
The value of Moose::_throw_on_error at construction.
Definition: Moose.h:347
static void registerObjectsTo(Factory &f, const std::set< std::string > &labels)
This registers all MooseObjects known to the registry that have the given label(s) with the factory f...
Definition: Registry.C:35
const ExecFlagType EXEC_POST_ADAPTIVITY
Definition: Moose.C:58
Registered base class for linear FV interpolation objects.
All Distributions should inherit from this class.
Definition: Distribution.h:18
Class to transfer MFEM variable data to or from a restricted copy of the variable defined on an a sub...
Base class for MeshDivision objects.
Definition: MeshDivision.h:35
Reporter objects allow for the declaration of arbitrary data types that are aggregate values for a si...
Definition: Reporter.h:47
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Base class for MOOSE preconditioners.
Based class for output objects.
Definition: Output.h:43
ScopedThrowOnError()
Default constructor, which sets Moose::_throw_on_error = true.
Definition: Moose.C:832
FunctorMaterials compute functor material properties.
const ExecFlagType EXEC_ALWAYS
Definition: Moose.C:51
static void registerActionsTo(ActionFactory &f, const std::set< std::string > &labels)
This registers all Actions known to the registry that have the given label(s) with the factory f...
Definition: Registry.C:69
Base class for convergence criteria.
Definition: Convergence.h:21
The DGKernel class is responsible for calculating the residuals for various physics on internal sides...
Definition: DGKernel.h:18
bool _deprecated_is_error
Variable to toggle only deprecated warnings as errors.
Definition: Moose.C:863
static bool _color_console
Definition: Moose.C:810
Base class for making kernels that work on auxiliary scalar variables.
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_ITERATION_END
Definition: Moose.C:38
Base class for construction of a mfem::ParSubMesh object.
Definition: MFEMSubMesh.h:20
const ExecFlagType EXEC_TRANSFER
Definition: Moose.C:55
~ScopedThrowOnError()
Destructor, which sets Moose::_throw_on_error to what it was upon construction.
Definition: Moose.C:834
Base class for array variable (equation) kernels using automatic differentiation. ...
Definition: ADArrayKernel.h:19
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:48
Base class for creating kernels that interface physics between subdomains.
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:93
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
const ExecFlagType EXEC_FAILED
Definition: Moose.C:48
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:30
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:363
Base class for all Postprocessors.
Definition: Postprocessor.h:23
The behavior of this kernel is controlled by one problem-wise global parameter eigen_on_current - boo...
Definition: EigenKernel.h:23
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN
Definition: Moose.C:42
const ExecFlagType EXEC_TIMESTEP_END
Definition: Moose.C:36
InitialConditions are objects that set the initial value of variables.
A DiracKernel is used when you need to add contributions to the residual by means of multiplying some...
Definition: DiracKernel.h:19
Constructs and stores an mfem::ParFiniteElementSpace object.
Definition: MFEMFESpace.h:20
void addDependencySets(const std::string &action_sets)
Adds all dependencies in a single call.
Definition: Syntax.C:69
Base class for wrapping mfem::Solver-derived classes.
FVKernel is a base class for all finite volume method kernels.
Definition: FVKernel.h:32
Base class for creating new types of boundary conditions.
Base class for time integrators.
bool show_multiple
Set to false (the default) to display an error message only once for each error call code location (a...
Definition: Moose.C:867
Class for containing MooseEnum item information.
Definition: MooseEnumItem.h:18
Base class for Control objects.
Definition: Control.h:34
bool _throw_on_warning
Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests...
Definition: Moose.C:865
void registerSyntaxType(const std::string &syntax, const std::string &type)
Register a type with a block.
Definition: Syntax.C:362
void registerAll(Factory &f, ActionFactory &af, Syntax &s)
Register objects that are in MOOSE.
Definition: Moose.C:67
void registerObjects(Factory &factory, const std::set< std::string > &obj_labels)
Definition: Moose.C:96
Base class for MOOSE partitioner.
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
Definition: Moose.C:819
Base class for deriving dampers.
Definition: Damper.h:24
Scoped helper for setting Moose::_throw_on_error during this scope.
Definition: Moose.h:295
Holding syntax for parsing input files.
Definition: Syntax.h:21
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END
Definition: Moose.C:40
const ExecFlagType EXEC_CUSTOM
Definition: Moose.C:49
Definition: Kernel.h:15
const ExecFlagType EXEC_SUBDOMAIN
Definition: Moose.C:50
int interrupt_signal_number
Used by the signal handler to determine if we should write a checkpoint file out at any point during ...
Definition: Moose.C:866
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
const ExecFlagType EXEC_POSTCHECK
Definition: Moose.C:35
const ExecFlagType EXEC_FORCED
Definition: Moose.C:47
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
const ExecFlagType EXEC_SAME_AS_MULTIAPP
Definition: Moose.C:53
const ExecFlagType EXEC_FINAL
Definition: Moose.C:46
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30
const ExecFlagType EXEC_NONE
Definition: Moose.C:29
Base class for creating nodal kernels with hand-coded Jacobians.
Definition: NodalKernel.h:18
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112
std::string hitMessagePrefix(const hit::Node &node)
Get the prefix to be associated with a hit node for a message.
Definition: Moose.C:851
Base class for Postprocessors that produce a vector of values.
bool _throw_on_error
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or wh...
Definition: Moose.C:864
MaterialBases compute MaterialProperties.
Definition: MaterialBase.h:62
Scoped helper for setting Moose::_deprecated_is_error during this scope.
Definition: Moose.h:325
MeshGenerators are objects that can modify or add to an existing mesh.
Definition: MeshGenerator.h:33
This is a template class that implements the workhorse compute and computeNodal methods.
Base class for user-specific data.
Definition: UserObject.h:19
void addActionTypes(Syntax &syntax)
Definition: Moose.C:102
Base variable class.
The Executor class directs the execution flow of simulations.
Definition: Executor.h:26
const ExecFlagType EXEC_NONLINEAR_CONVERGENCE
Definition: Moose.C:34
void associateSyntaxInner(Syntax &syntax, ActionFactory &action_factory)
Definition: Moose.C:561
Control that additionally provides the capability to produce/consume data values, to allow control op...
Definition: ChainControl.h:21
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE
Definition: Moose.C:44
Base class for all Transfer objects.
Definition: Transfer.h:36
const ExecFlagType EXEC_PRE_DISPLACE
Definition: Moose.C:52