Line data Source code
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");
38 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_ITERATION_END =
39 : registerExecFlag("MULTIAPP_FIXED_POINT_ITERATION_END");
40 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END =
41 : registerDefaultExecFlag("MULTIAPP_FIXED_POINT_END");
42 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN =
43 : registerDefaultExecFlag("MULTIAPP_FIXED_POINT_BEGIN");
44 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE =
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
67 67400 : registerAll(Factory & f, ActionFactory & af, Syntax & s)
68 : {
69 67400 : registerObjects(f, {"MooseApp"});
70 67400 : associateSyntaxInner(s, af);
71 67400 : registerActions(s, af, {"MooseApp"});
72 269600 : registerAppDataFilePath("moose");
73 269600 : 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 337000 : 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 67400 : }
94 :
95 : void
96 67400 : registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
97 : {
98 67400 : Registry::registerObjectsTo(factory, obj_labels);
99 67400 : }
100 :
101 : void
102 67400 : addActionTypes(Syntax & syntax)
103 : {
104 : /**
105 : * The (optional) last param here indicates whether the task should trigger an Action auto-build.
106 : * If a task is marked as "true". Then MOOSE will attempt to build the associated Action if one is
107 : * not supplied by some other means (usually through the input file or custom Action). Only
108 : * Actions that do not have required parameters and have defaults for all optional parameters can
109 : * be built automatically (See ActionWarehouse.C).
110 : *
111 : * Note: Many of the actions in the "Minimal Problem" section are marked as false. However, we
112 : * can generally force creation of these "Action"s as needed by registering them to syntax that we
113 : * expect to see even if those "Action"s don't normally pick up parameters from the input file.
114 : */
115 :
116 : // clang-format off
117 : /**************************/
118 : /**** Register Actions ****/
119 : /**************************/
120 269600 : registerMooseObjectTask("create_problem", Problem, false);
121 269600 : registerMooseObjectTask("setup_executioner", Executioner, false);
122 269600 : registerMooseObjectTask("read_executor", Executor, false);
123 134800 : registerTask("add_executor", true);
124 :
125 : // TODO Organize these somewhere
126 134800 : registerTask("init_physics", false);
127 134800 : registerTask("init_component_physics", false);
128 134800 : registerTask("meta_action_component", false);
129 134800 : registerTask("setup_component", false);
130 : // 'list_component' is used to retrieve ActionComponents for the syntax JSON
131 134800 : 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 269600 : registerMooseObjectTask("determine_system_type", Executioner, true);
136 :
137 269600 : registerMooseObjectTask("setup_mesh", MooseMesh, false);
138 269600 : registerMooseObjectTask("set_mesh_base", MooseMesh, false);
139 269600 : registerMooseObjectTask("init_mesh", MooseMesh, false);
140 269600 : registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
141 134800 : registerTask("create_added_mesh_generators", true);
142 269600 : registerMooseObjectTask("append_mesh_generator", MeshGenerator, false);
143 :
144 269600 : registerMooseObjectTask("add_kernel", Kernel, false);
145 269600 : appendMooseObjectTask ("add_kernel", EigenKernel);
146 269600 : appendMooseObjectTask ("add_kernel", VectorKernel);
147 269600 : appendMooseObjectTask ("add_kernel", ArrayKernel);
148 269600 : appendMooseObjectTask ("add_kernel", ADArrayKernel);
149 :
150 269600 : registerMooseObjectTask("add_variable", MooseVariableBase, false);
151 269600 : registerMooseObjectTask("add_aux_variable", MooseVariableBase, false);
152 269600 : registerMooseObjectTask("add_elemental_field_variable", MooseVariableBase, false);
153 269600 : registerMooseObjectTask("add_variables_physics", MooseVariableBase, false);
154 :
155 269600 : registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
156 :
157 269600 : registerMooseObjectTask("add_functor_material", FunctorMaterial, false);
158 269600 : registerMooseObjectTask("add_material", MaterialBase, false);
159 269600 : appendDeprecatedMooseObjectTask("add_material", FunctorMaterial);
160 269600 : registerMooseObjectTask("add_materials_physics", FunctorMaterial, false);
161 269600 : appendMooseObjectTask ("add_materials_physics", MaterialBase);
162 :
163 269600 : registerMooseObjectTask("add_bc", BoundaryCondition, false);
164 :
165 269600 : registerMooseObjectTask("add_function", Function, false);
166 :
167 269600 : registerMooseObjectTask("add_distribution", Distribution, false);
168 269600 : registerMooseObjectTask("add_sampler", Sampler, false);
169 :
170 269600 : registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
171 269600 : appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
172 269600 : appendMooseObjectTask ("add_aux_kernel", ArrayAuxKernel);
173 :
174 269600 : registerMooseObjectTask("add_bound", Bounds, false);
175 :
176 269600 : registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
177 269600 : registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
178 269600 : registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
179 269600 : appendMooseObjectTask ("add_dirac_kernel", VectorDiracKernel);
180 269600 : registerMooseObjectTask("add_dg_kernel", DGKernel, false);
181 269600 : registerMooseObjectTask("add_fv_kernel", FVKernel, false);
182 269600 : registerMooseObjectTask("add_interpolation_method", FVInterpolationMethod, false);
183 269600 : registerMooseObjectTask("add_linear_fv_kernel", LinearFVKernel, false);
184 269600 : registerMooseObjectTask("add_fv_bc", FVBoundaryCondition, false);
185 269600 : registerMooseObjectTask("add_linear_fv_bc", LinearFVBoundaryCondition, false);
186 269600 : registerMooseObjectTask("add_fv_ik", FVInterfaceKernel, false);
187 269600 : registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
188 269600 : appendMooseObjectTask ("add_interface_kernel", VectorInterfaceKernel);
189 269600 : registerMooseObjectTask("add_constraint", Constraint, false);
190 269600 : registerMooseObjectTask("add_hybridized_kernel", HDGKernel, false);
191 269600 : registerMooseObjectTask("add_hybridized_integrated_bc", HDGIntegratedBC, false);
192 :
193 269600 : registerMooseObjectTask("add_ic", InitialCondition, false);
194 269600 : appendMooseObjectTask ("add_ic", ScalarInitialCondition);
195 269600 : registerMooseObjectTask("add_fv_ic", FVInitialCondition, false);
196 269600 : registerMooseObjectTask("add_ics_physics", InitialCondition, false);
197 269600 : appendMooseObjectTask ("add_ics_physics", FVInitialCondition);
198 269600 : appendMooseObjectTask ("add_ics_physics", ScalarInitialCondition);
199 :
200 269600 : registerMooseObjectTask("add_damper", Damper, false);
201 269600 : registerMooseObjectTask("setup_predictor", Predictor, false);
202 269600 : registerMooseObjectTask("add_time_steppers", TimeStepper, false);
203 269600 : registerMooseObjectTask("add_time_stepper", TimeStepper, false);
204 134800 : registerTask ("compose_time_stepper", true);
205 269600 : registerMooseObjectTask("setup_time_integrators", TimeIntegrator, false);
206 269600 : registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
207 269600 : registerMooseObjectTask("add_convergence", Convergence, false);
208 :
209 269600 : registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
210 269600 : registerMooseObjectTask("add_field_split", Split, false);
211 :
212 269600 : registerMooseObjectTask("add_mesh_division", MeshDivision, false);
213 269600 : registerMooseObjectTask("add_user_object", UserObject, false);
214 269600 : appendMooseObjectTask ("add_user_object", Postprocessor);
215 :
216 269600 : appendDeprecatedMooseObjectTask("add_user_object", Corrector);
217 269600 : registerMooseObjectTask("add_corrector", Corrector, false);
218 269600 : appendDeprecatedMooseObjectTask("add_user_object", MeshModifier);
219 269600 : registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
220 :
221 269600 : registerMooseObjectTask("add_postprocessor", Postprocessor, false);
222 269600 : registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
223 269600 : registerMooseObjectTask("add_reporter", Reporter, false);
224 :
225 269600 : registerMooseObjectTask("add_positions", Positions, false);
226 269600 : registerMooseObjectTask("add_times", Times, false);
227 :
228 269600 : registerMooseObjectTask("add_indicator", Indicator, false);
229 269600 : registerMooseObjectTask("add_marker", Marker, false);
230 :
231 269600 : registerMooseObjectTask("add_multi_app", MultiApp, false);
232 269600 : registerMooseObjectTask("add_transfer", Transfer, false);
233 :
234 269600 : registerMooseObjectTask("add_output", Output, false);
235 :
236 269600 : registerMooseObjectTask("add_control", Control, false);
237 269600 : registerMooseObjectTask("add_chain_control", ChainControl, false);
238 269600 : registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
239 :
240 : // clang-format on
241 :
242 134800 : registerTask("dynamic_object_registration", false);
243 134800 : registerTask("common_output", true);
244 134800 : registerTask("setup_recover_file_base", true);
245 134800 : registerTask("recover_meta_data", true);
246 :
247 134800 : registerTask("add_bounds_vectors", false);
248 134800 : registerTask("add_periodic_bc", false);
249 134800 : registerTask("add_aux_variable", false);
250 134800 : registerTask("add_external_aux_variables", true);
251 134800 : registerTask("add_variable", false);
252 134800 : registerTask("add_mortar_variable", false);
253 :
254 134800 : registerTask("execute_mesh_generators", true);
255 134800 : registerTask("uniform_refine_mesh", false);
256 134800 : registerTask("prepare_mesh", false);
257 134800 : registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
258 134800 : registerTask("setup_mesh_complete", true); // calls prepare
259 134800 : registerTask("post_mesh_prepared", false);
260 134800 : registerTask("add_geometric_rm", false);
261 134800 : registerTask("attach_geometric_rm", true);
262 134800 : registerTask("attach_geometric_rm_final", true);
263 :
264 134800 : registerTask("init_displaced_problem", false);
265 :
266 134800 : registerTask("add_algebraic_rm", false);
267 134800 : registerTask("attach_algebraic_rm", true);
268 134800 : registerTask("add_coupling_rm", false);
269 134800 : registerTask("attach_coupling_rm", true);
270 134800 : registerTask("init_problem", true);
271 134800 : registerTask("check_copy_nodal_vars", true);
272 134800 : registerTask("copy_nodal_vars", true);
273 134800 : registerTask("copy_nodal_aux_vars", true);
274 134800 : registerTask("copy_vars_physics", false);
275 134800 : registerTask("setup_postprocessor_data", false);
276 134800 : registerTask("setup_time_steppers", true);
277 :
278 134800 : registerTask("setup_dampers", true);
279 134800 : registerTask("check_integrity", true);
280 134800 : registerTask("resolve_optional_materials", true);
281 134800 : registerTask("check_integrity_early", true);
282 134800 : registerTask("check_integrity_early_physics", false);
283 134800 : registerTask("setup_quadrature", true);
284 134800 : registerTask("create_tagged_matrices", true);
285 :
286 134800 : registerTask("mesh_modifiers", false);
287 :
288 : /// Additional Actions
289 134800 : registerTask("no_action", false); // Used for Empty Action placeholders
290 134800 : registerTask("set_global_params", false);
291 134800 : registerTask("setup_adaptivity", false);
292 134800 : registerTask("meta_action", false);
293 134800 : registerTask("setup_residual_debug", false);
294 134800 : registerTask("setup_oversampling", false);
295 134800 : registerTask("deprecated_block", false);
296 134800 : registerTask("set_adaptivity_options", false);
297 134800 : registerTask("add_mortar_interface", false);
298 134800 : registerTask("coupling_functor_check", true);
299 134800 : registerTask("add_master_action_material", false);
300 134800 : registerTask("setup_projected_properties", false);
301 134800 : registerTask("create_application_block", false);
302 :
303 : // Dummy Actions (useful for sync points in the dependencies)
304 134800 : registerTask("setup_function_complete", false);
305 134800 : registerTask("setup_variable_complete", false);
306 134800 : registerTask("setup_executioner_complete", false);
307 134800 : registerTask("ready_to_init", true);
308 :
309 : // Output related actions
310 134800 : registerTask("add_output_aux_variables", true);
311 134800 : registerTask("check_output", true);
312 134800 : registerTask("declare_late_reporters", true);
313 :
314 134800 : registerTask("create_problem_default", true);
315 134800 : registerTask("create_problem_custom", false);
316 134800 : registerTask("create_problem_complete", false);
317 :
318 134800 : registerTask("add_default_nonlinear_convergence", true);
319 134800 : registerTask("add_default_multiapp_fixed_point_convergence", true);
320 134800 : registerTask("add_default_steady_state_convergence", true);
321 :
322 134800 : registerTask("chain_control_setup", true);
323 134800 : registerTask("start_webservercontrol", true);
324 :
325 : // Action for setting up the signal-based checkpoint
326 134800 : registerTask("auto_checkpoint_action", true);
327 : /**************************/
328 : /****** Dependencies ******/
329 : /**************************/
330 : /**
331 : * The following is the default set of action dependencies for a basic MOOSE problem. The
332 : * formatting of this string is important. Each line represents a set of dependencies that depend
333 : * on the previous line. Items on the same line have equal weight and can be executed in any
334 : * order.
335 : *
336 : * Additional dependencies can be inserted later inside of user applications with calls to
337 : * ActionWarehouse::addDependency("task", "pre_req")
338 : */
339 :
340 : // clang-format off
341 134800 : 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 101080 : registerTask("add_mfem_problem_operator", true);
458 202160 : addTaskDependency("add_mfem_problem_operator", "init_mesh");
459 202160 : addTaskDependency("add_variable", "add_mfem_problem_operator");
460 202160 : addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
461 202160 : addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
462 202160 : addTaskDependency("add_bc", "add_mfem_problem_operator");
463 202160 : addTaskDependency("add_kernel", "add_mfem_problem_operator");
464 :
465 : // add SubMeshes
466 202160 : registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
467 202160 : addTaskDependency("add_mfem_submeshes", "create_problem_complete");
468 :
469 : // add SubMesh transfers
470 202160 : appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
471 :
472 : // add FESpaces
473 202160 : registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
474 202160 : appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
475 202160 : addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
476 202160 : addTaskDependency("add_variable", "add_mfem_fespaces");
477 202160 : addTaskDependency("add_aux_variable", "add_mfem_fespaces");
478 202160 : addTaskDependency("add_elemental_field_variable", "add_mfem_fespaces");
479 202160 : addTaskDependency("add_kernel", "add_mfem_fespaces");
480 :
481 : // add complex kernels
482 202160 : registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
483 202160 : registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
484 202160 : addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
485 202160 : addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
486 202160 : addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
487 202160 : addTaskDependency("add_mfem_complex_bc_components", "add_bc");
488 :
489 : // set mesh FE space
490 101080 : registerTask("set_mesh_fe_space", true);
491 202160 : addTaskDependency("set_mesh_fe_space", "add_variable");
492 202160 : addTaskDependency("set_mesh_fe_space", "init_mesh");
493 :
494 : // add preconditioning.
495 202160 : registerMooseObjectTask("add_mfem_preconditioner", Moose::MFEM::SolverBase, false);
496 202160 : addTaskDependency("add_mfem_preconditioner", "add_mfem_problem_operator");
497 202160 : addTaskDependency("add_mfem_preconditioner", "add_variable");
498 :
499 : // add solver objects.
500 202160 : registerMooseObjectTask("add_mfem_solver", Moose::MFEM::SolverBase, true);
501 202160 : addTaskDependency("add_mfem_solver", "add_mfem_preconditioner");
502 202160 : addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
503 : #endif
504 :
505 : // Linear FV kernels fetch FVInterpolationMethod instances in their constructors
506 269600 : addTaskDependency("add_linear_fv_kernel", "add_interpolation_method");
507 :
508 134800 : registerTask("parse_neml2", /*required=*/false);
509 269600 : addTaskDependency("add_material", "parse_neml2");
510 202200 : addTaskDependency("add_user_object", "parse_neml2");
511 67400 : }
512 :
513 : /**
514 : * Multiple Action class can be associated with a single input file section, in which case all
515 : * associated Actions will be created and "acted" on when the associated input file section is
516 : * seen.*
517 : *
518 : * Example:
519 : * "setup_mesh" <-----------> SetupMeshAction <---------
520 : * \
521 : * [Mesh]
522 : * /
523 : * "setup_mesh_complete" <---> SetupMeshCompleteAction <-
524 : *
525 : *
526 : * Action classes can also be registered to act on more than one input file section for a different
527 : * task if similar logic can work in multiple cases
528 : *
529 : * Example:
530 : * "add_variable" <----- -> [Variables/ *]
531 : * \ /
532 : * CopyNodalVarsAction
533 : * / \
534 : * "add_aux_variable" <- -> [AuxVariables/ *]
535 : *
536 : *
537 : * Note: Placeholder "no_action" actions must be put in places where it is possible to match an
538 : * object with a star or a more specific parent later on. (i.e. where one needs to negate the
539 : * '*' matching prematurely).
540 : */
541 : void
542 0 : registerActions(Syntax & syntax, ActionFactory & action_factory)
543 : {
544 0 : mooseDeprecated("use registerAll instead of registerActions");
545 0 : registerActions(syntax, action_factory, {"MooseApp"});
546 0 : }
547 :
548 : void
549 67400 : registerActions(Syntax & syntax,
550 : ActionFactory & action_factory,
551 : const std::set<std::string> & obj_labels)
552 : {
553 67400 : Registry::registerActionsTo(action_factory, obj_labels);
554 :
555 : // Add these actions here so they are always executed last, without setting any dependency
556 134800 : registerTask("dump_objects", false);
557 67400 : registerTask("finish_input_file_output", false);
558 67400 : }
559 :
560 : void
561 67400 : associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
562 : {
563 : /**
564 : * Note: the optional third parameter is used to differentiate which task is
565 : * satisfied based on the syntax encountered for classes which are registered
566 : * to satisfy more than one task
567 : */
568 539200 : registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
569 539200 : registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
570 :
571 539200 : registerSyntax("AddActionComponentAction", "ActionComponents/*");
572 539200 : registerSyntax("CombineComponentsMeshes", "ActionComponents");
573 :
574 539200 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
575 539200 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
576 539200 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
577 539200 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
578 :
579 539200 : registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
580 539200 : registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
581 539200 : registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
582 :
583 539200 : registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
584 :
585 539200 : registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
586 :
587 539200 : registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
588 539200 : registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
589 :
590 539200 : registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
591 :
592 539200 : registerSyntax("CreateProblemAction", "Problem");
593 539200 : registerSyntax("DynamicObjectRegistrationAction", "Problem");
594 :
595 539200 : registerSyntax("SetupMeshAction", "Mesh");
596 539200 : registerSyntax("SetupMeshCompleteAction", "Mesh");
597 : // Components should be able create a Mesh without a Mesh block
598 539200 : registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
599 539200 : registerSyntax("CreateDisplacedProblemAction", "Mesh");
600 539200 : registerSyntax("DisplayGhostingAction", "Mesh");
601 539200 : registerSyntax("AddMeshGeneratorAction", "Mesh/*");
602 539200 : registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
603 539200 : registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
604 539200 : registerSyntax("ElementIDOutputAction", "Mesh");
605 269600 : syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
606 :
607 539200 : registerSyntax("AddFunctionAction", "Functions/*");
608 269600 : syntax.registerSyntaxType("Functions/*", "FunctionName");
609 :
610 539200 : registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
611 269600 : syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
612 539200 : registerSyntax("AddConvergenceAction", "Convergence/*");
613 269600 : syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
614 :
615 539200 : registerSyntax("GlobalParamsAction", "GlobalParams");
616 :
617 539200 : registerSyntax("AddDistributionAction", "Distributions/*");
618 269600 : syntax.registerSyntaxType("Distributions/*", "DistributionName");
619 :
620 539200 : registerSyntax("AddSamplerAction", "Samplers/*");
621 269600 : syntax.registerSyntaxType("Samplers/*", "SamplerName");
622 :
623 539200 : registerSyntax("SetupDebugAction", "Debug");
624 539200 : registerSyntax("SetupResidualDebugAction", "Debug");
625 :
626 : /// Variable/AuxVariable Actions
627 539200 : registerSyntax("AddVariableAction", "Variables/*");
628 269600 : syntax.registerSyntaxType("Variables/*", "VariableName");
629 269600 : syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
630 :
631 539200 : registerSyntax("AddICAction", "Variables/*/InitialCondition");
632 539200 : registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
633 :
634 539200 : registerSyntax("AddAuxVariableAction", "AuxVariables/*");
635 269600 : syntax.registerSyntaxType("AuxVariables/*", "VariableName");
636 269600 : syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
637 :
638 539200 : registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
639 539200 : registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
640 :
641 539200 : registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
642 539200 : registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
643 :
644 539200 : registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
645 539200 : registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
646 :
647 539200 : registerSyntax("AddMaterialAction", "Materials/*");
648 269600 : syntax.registerSyntaxType("Materials/*", "MaterialName");
649 :
650 539200 : registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
651 269600 : syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
652 :
653 539200 : registerSyntax("AddPostprocessorAction", "Postprocessors/*");
654 269600 : syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
655 269600 : syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
656 :
657 539200 : registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
658 269600 : syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
659 :
660 539200 : registerSyntax("AddReporterAction", "Reporters/*");
661 269600 : syntax.registerSyntaxType("Reporters/*", "ReporterName");
662 :
663 539200 : registerSyntax("AddPositionsAction", "Positions/*");
664 269600 : syntax.registerSyntaxType("Positions/*", "PositionsName");
665 :
666 539200 : registerSyntax("AddTimesAction", "Times/*");
667 269600 : syntax.registerSyntaxType("Times/*", "TimesName");
668 :
669 539200 : registerSyntax("AddDamperAction", "Dampers/*");
670 :
671 539200 : registerSyntax("AddOutputAction", "Outputs/*");
672 539200 : registerSyntax("CommonOutputAction", "Outputs");
673 539200 : registerSyntax("MaterialOutputAction", "Outputs");
674 539200 : registerSyntax("AutoCheckpointAction", "Outputs");
675 269600 : syntax.registerSyntaxType("Outputs/*", "OutputName");
676 :
677 : // Note: Preconditioner Actions will be built by this setup action
678 539200 : registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
679 539200 : registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
680 :
681 539200 : registerSyntax("CreateExecutionerAction", "Executioner");
682 539200 : registerSyntax("ReadExecutorParamsAction", "Executors/*");
683 :
684 539200 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
685 539200 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
686 539200 : registerSyntaxTask(
687 : "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
688 539200 : registerSyntaxTask(
689 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
690 539200 : registerSyntaxTask(
691 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
692 269600 : syntax.registerSyntaxType("Executors/*", "ExecutorName");
693 :
694 539200 : registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
695 539200 : registerSyntax("SetupPredictorAction", "Executioner/Predictor");
696 : #ifdef LIBMESH_ENABLE_AMR
697 539200 : registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
698 : #endif
699 :
700 539200 : registerSyntax("PartitionerAction", "Mesh/Partitioner");
701 :
702 539200 : registerSyntax("AddDiracKernelAction", "DiracKernels/*");
703 :
704 539200 : registerSyntax("AddDGKernelAction", "DGKernels/*");
705 539200 : registerSyntax("AddFVKernelAction", "FVKernels/*");
706 539200 : registerSyntax("AddFVBCAction", "FVBCs/*");
707 539200 : registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
708 539200 : registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
709 539200 : registerSyntax("CheckFVBCAction", "FVBCs");
710 :
711 539200 : registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
712 :
713 539200 : registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
714 :
715 539200 : registerSyntax("AddConstraintAction", "Constraints/*");
716 :
717 539200 : registerSyntax("AddControlAction", "Controls/*");
718 539200 : registerSyntax("AddChainControlAction", "ChainControls/*");
719 539200 : registerSyntax("AddBoundAction", "Bounds/*");
720 539200 : registerSyntax("AddBoundsVectorsAction", "Bounds");
721 :
722 : // UserObject and some derived classes
723 539200 : registerSyntax("AddUserObjectAction", "UserObjects/*");
724 269600 : syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
725 :
726 539200 : registerSyntax("AddCorrectorAction", "Correctors/*");
727 269600 : syntax.registerSyntaxType("Correctors/*", "UserObjectName");
728 :
729 539200 : registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
730 269600 : syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
731 :
732 539200 : registerSyntax("AddNodalNormalsAction", "NodalNormals");
733 :
734 : // FVInterpolationMethods
735 539200 : registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
736 269600 : syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
737 :
738 : // Indicator
739 539200 : registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
740 539200 : registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
741 269600 : syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
742 :
743 : // Marker
744 539200 : registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
745 539200 : registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
746 269600 : syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
747 :
748 : // New Adaptivity System
749 539200 : registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
750 :
751 : // Deprecated Block
752 539200 : registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
753 :
754 : // Multi Apps
755 539200 : registerSyntax("AddMultiAppAction", "MultiApps/*");
756 269600 : syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
757 :
758 : // Transfers
759 539200 : registerSyntax("AddTransferAction", "Transfers/*");
760 :
761 : // Material derivative test
762 539200 : registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
763 539200 : registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
764 :
765 539200 : registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
766 :
767 : // Application Block System
768 539200 : registerSyntax("CreateApplicationBlockAction", "Application");
769 :
770 : #ifdef MOOSE_MFEM_ENABLED
771 404320 : registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
772 404320 : registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
773 404320 : registerSyntaxTask(
774 : "AddMFEMComplexKernelComponentAction", "Kernels/*/*", "add_mfem_complex_kernel_components");
775 404320 : registerSyntaxTask(
776 : "AddMFEMComplexBCComponentAction", "BCs/*/*", "add_mfem_complex_bc_components");
777 404320 : registerSyntaxTask("AddMFEMPreconditionerAction", "Preconditioner/*", "add_mfem_preconditioner");
778 404320 : registerSyntaxTask("AddMFEMSolverAction", "Solvers/*", "add_mfem_solver");
779 202160 : syntax.registerSyntaxType("Solvers/*", "MFEMSolverName");
780 : #endif
781 :
782 539200 : registerSyntax("NEML2ActionCommon", "NEML2");
783 471800 : registerSyntax("NEML2Action", "NEML2/*");
784 :
785 67400 : addActionTypes(syntax);
786 67400 : }
787 :
788 : void
789 0 : associateSyntax(Syntax & syntax, ActionFactory & action_factory)
790 : {
791 0 : associateSyntaxInner(syntax, action_factory);
792 0 : registerActions(syntax, action_factory);
793 0 : }
794 :
795 : void
796 0 : setSolverDefaults(FEProblemBase & problem)
797 : {
798 : // May be a touch expensive to create a new DM every time, but probably safer to do it this way
799 0 : Moose::PetscSupport::petscSetDefaults(problem);
800 0 : }
801 :
802 : MPI_Comm
803 1207098 : swapLibMeshComm(MPI_Comm new_comm)
804 : {
805 1207098 : MPI_Comm old_comm = PETSC_COMM_WORLD;
806 1207098 : PETSC_COMM_WORLD = new_comm;
807 1207098 : return old_comm;
808 : }
809 :
810 : static bool _color_console = isatty(fileno(stdout));
811 :
812 : bool
813 9759613 : colorConsole()
814 : {
815 9759613 : return _color_console;
816 : }
817 :
818 : bool
819 54840 : setColorConsole(bool use_color, bool force)
820 : {
821 54840 : _color_console = (isatty(fileno(stdout)) || force) && use_color;
822 54840 : return _color_console;
823 : }
824 :
825 2731481 : ScopedThrowOnError::ScopedThrowOnError(const bool throw_on_error)
826 2731481 : : _throw_on_error_before(Moose::_throw_on_error)
827 : {
828 : mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
829 2731481 : Moose::_throw_on_error = throw_on_error;
830 2731481 : }
831 :
832 2731481 : ScopedThrowOnError::ScopedThrowOnError() : ScopedThrowOnError(true) {}
833 :
834 2731481 : ScopedThrowOnError::~ScopedThrowOnError() { Moose::_throw_on_error = _throw_on_error_before; }
835 :
836 6 : ScopedDeprecatedIsError::ScopedDeprecatedIsError(const bool deprecated_is_error)
837 6 : : _deprecated_is_error_before(Moose::_deprecated_is_error)
838 : {
839 : mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
840 6 : Moose::_deprecated_is_error = deprecated_is_error;
841 6 : }
842 :
843 0 : ScopedDeprecatedIsError::ScopedDeprecatedIsError() : ScopedDeprecatedIsError(true) {}
844 :
845 6 : ScopedDeprecatedIsError::~ScopedDeprecatedIsError()
846 : {
847 6 : Moose::_deprecated_is_error = _deprecated_is_error_before;
848 6 : }
849 :
850 : std::string
851 16243 : hitMessagePrefix(const hit::Node & node)
852 : {
853 : // Strip meaningless line and column number for CLI args
854 16243 : if (node.filename() == "CLI_ARGS")
855 1264 : return "CLI_ARGS:\n";
856 : // If using the root node, don't add line info
857 15611 : if (node.isRoot())
858 3 : return node.filename() + ":\n";
859 15608 : 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;
866 : int interrupt_signal_number = 0;
867 : bool show_multiple = false;
868 :
869 : } // namespace Moose
|
