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 67415 : registerAll(Factory & f, ActionFactory & af, Syntax & s)
68 : {
69 67415 : registerObjects(f, {"MooseApp"});
70 67415 : associateSyntaxInner(s, af);
71 67415 : registerActions(s, af, {"MooseApp"});
72 269660 : registerAppDataFilePath("moose");
73 269660 : 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 337075 : 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 67415 : }
94 :
95 : void
96 67415 : registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
97 : {
98 67415 : Registry::registerObjectsTo(factory, obj_labels);
99 67415 : }
100 :
101 : void
102 67415 : 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 269660 : registerMooseObjectTask("create_problem", Problem, false);
121 269660 : registerMooseObjectTask("setup_executioner", Executioner, false);
122 269660 : registerMooseObjectTask("read_executor", Executor, false);
123 134830 : registerTask("add_executor", true);
124 :
125 : // TODO Organize these somewhere
126 134830 : registerTask("init_physics", false);
127 134830 : registerTask("init_component_physics", false);
128 134830 : registerTask("meta_action_component", false);
129 134830 : registerTask("setup_component", false);
130 : // 'list_component' is used to retrieve ActionComponents for the syntax JSON
131 134830 : 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 269660 : registerMooseObjectTask("determine_system_type", Executioner, true);
136 :
137 269660 : registerMooseObjectTask("setup_mesh", MooseMesh, false);
138 269660 : registerMooseObjectTask("set_mesh_base", MooseMesh, false);
139 269660 : registerMooseObjectTask("init_mesh", MooseMesh, false);
140 269660 : registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
141 134830 : registerTask("create_added_mesh_generators", true);
142 269660 : registerMooseObjectTask("append_mesh_generator", MeshGenerator, false);
143 :
144 269660 : registerMooseObjectTask("add_kernel", Kernel, false);
145 269660 : appendMooseObjectTask ("add_kernel", EigenKernel);
146 269660 : appendMooseObjectTask ("add_kernel", VectorKernel);
147 269660 : appendMooseObjectTask ("add_kernel", ArrayKernel);
148 269660 : appendMooseObjectTask ("add_kernel", ADArrayKernel);
149 :
150 269660 : registerMooseObjectTask("add_variable", MooseVariableBase, false);
151 269660 : registerMooseObjectTask("add_aux_variable", MooseVariableBase, false);
152 269660 : registerMooseObjectTask("add_elemental_field_variable", MooseVariableBase, false);
153 269660 : registerMooseObjectTask("add_variables_physics", MooseVariableBase, false);
154 :
155 269660 : registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
156 :
157 269660 : registerMooseObjectTask("add_functor_material", FunctorMaterial, false);
158 269660 : registerMooseObjectTask("add_material", MaterialBase, false);
159 269660 : appendDeprecatedMooseObjectTask("add_material", FunctorMaterial);
160 269660 : registerMooseObjectTask("add_materials_physics", FunctorMaterial, false);
161 269660 : appendMooseObjectTask ("add_materials_physics", MaterialBase);
162 :
163 269660 : registerMooseObjectTask("add_bc", BoundaryCondition, false);
164 :
165 269660 : registerMooseObjectTask("add_function", Function, false);
166 :
167 269660 : registerMooseObjectTask("add_distribution", Distribution, false);
168 269660 : registerMooseObjectTask("add_sampler", Sampler, false);
169 :
170 269660 : registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
171 269660 : appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
172 269660 : appendMooseObjectTask ("add_aux_kernel", ArrayAuxKernel);
173 :
174 269660 : registerMooseObjectTask("add_bound", Bounds, false);
175 :
176 269660 : registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
177 269660 : registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
178 269660 : registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
179 269660 : appendMooseObjectTask ("add_dirac_kernel", VectorDiracKernel);
180 269660 : registerMooseObjectTask("add_dg_kernel", DGKernel, false);
181 269660 : registerMooseObjectTask("add_fv_kernel", FVKernel, false);
182 269660 : registerMooseObjectTask("add_interpolation_method", FVInterpolationMethod, false);
183 269660 : registerMooseObjectTask("add_linear_fv_kernel", LinearFVKernel, false);
184 269660 : registerMooseObjectTask("add_fv_bc", FVBoundaryCondition, false);
185 269660 : registerMooseObjectTask("add_linear_fv_bc", LinearFVBoundaryCondition, false);
186 269660 : registerMooseObjectTask("add_fv_ik", FVInterfaceKernel, false);
187 269660 : registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
188 269660 : appendMooseObjectTask ("add_interface_kernel", VectorInterfaceKernel);
189 269660 : registerMooseObjectTask("add_constraint", Constraint, false);
190 269660 : registerMooseObjectTask("add_hybridized_kernel", HDGKernel, false);
191 269660 : registerMooseObjectTask("add_hybridized_integrated_bc", HDGIntegratedBC, false);
192 :
193 269660 : registerMooseObjectTask("add_ic", InitialCondition, false);
194 269660 : appendMooseObjectTask ("add_ic", ScalarInitialCondition);
195 269660 : registerMooseObjectTask("add_fv_ic", FVInitialCondition, false);
196 269660 : registerMooseObjectTask("add_ics_physics", InitialCondition, false);
197 269660 : appendMooseObjectTask ("add_ics_physics", FVInitialCondition);
198 269660 : appendMooseObjectTask ("add_ics_physics", ScalarInitialCondition);
199 :
200 269660 : registerMooseObjectTask("add_damper", Damper, false);
201 269660 : registerMooseObjectTask("setup_predictor", Predictor, false);
202 269660 : registerMooseObjectTask("add_time_steppers", TimeStepper, false);
203 269660 : registerMooseObjectTask("add_time_stepper", TimeStepper, false);
204 134830 : registerTask ("compose_time_stepper", true);
205 269660 : registerMooseObjectTask("setup_time_integrators", TimeIntegrator, false);
206 269660 : registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
207 269660 : registerMooseObjectTask("add_convergence", Convergence, false);
208 :
209 269660 : registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
210 269660 : registerMooseObjectTask("add_field_split", Split, false);
211 :
212 269660 : registerMooseObjectTask("add_mesh_division", MeshDivision, false);
213 269660 : registerMooseObjectTask("add_user_object", UserObject, false);
214 269660 : appendMooseObjectTask ("add_user_object", Postprocessor);
215 :
216 269660 : appendDeprecatedMooseObjectTask("add_user_object", Corrector);
217 269660 : registerMooseObjectTask("add_corrector", Corrector, false);
218 269660 : appendDeprecatedMooseObjectTask("add_user_object", MeshModifier);
219 269660 : registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
220 :
221 269660 : registerMooseObjectTask("add_postprocessor", Postprocessor, false);
222 269660 : registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
223 269660 : registerMooseObjectTask("add_reporter", Reporter, false);
224 :
225 269660 : registerMooseObjectTask("add_positions", Positions, false);
226 269660 : registerMooseObjectTask("add_times", Times, false);
227 :
228 269660 : registerMooseObjectTask("add_indicator", Indicator, false);
229 269660 : registerMooseObjectTask("add_marker", Marker, false);
230 :
231 269660 : registerMooseObjectTask("add_multi_app", MultiApp, false);
232 269660 : registerMooseObjectTask("add_transfer", Transfer, false);
233 :
234 269660 : registerMooseObjectTask("add_output", Output, false);
235 :
236 269660 : registerMooseObjectTask("add_control", Control, false);
237 269660 : registerMooseObjectTask("add_chain_control", ChainControl, false);
238 269660 : registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
239 :
240 : // clang-format on
241 :
242 134830 : registerTask("dynamic_object_registration", false);
243 134830 : registerTask("common_output", true);
244 134830 : registerTask("setup_recover_file_base", true);
245 134830 : registerTask("recover_meta_data", true);
246 :
247 134830 : registerTask("add_bounds_vectors", false);
248 134830 : registerTask("add_periodic_bc", false);
249 134830 : registerTask("add_aux_variable", false);
250 134830 : registerTask("add_external_aux_variables", true);
251 134830 : registerTask("add_variable", false);
252 134830 : registerTask("add_mortar_variable", false);
253 :
254 134830 : registerTask("execute_mesh_generators", true);
255 134830 : registerTask("uniform_refine_mesh", false);
256 134830 : registerTask("prepare_mesh", false);
257 134830 : registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
258 134830 : registerTask("setup_mesh_complete", true); // calls prepare
259 134830 : registerTask("post_mesh_prepared", false);
260 134830 : registerTask("add_geometric_rm", false);
261 134830 : registerTask("attach_geometric_rm", true);
262 134830 : registerTask("attach_geometric_rm_final", true);
263 :
264 134830 : registerTask("init_displaced_problem", false);
265 :
266 134830 : registerTask("add_algebraic_rm", false);
267 134830 : registerTask("attach_algebraic_rm", true);
268 134830 : registerTask("add_coupling_rm", false);
269 134830 : registerTask("attach_coupling_rm", true);
270 134830 : registerTask("init_problem", true);
271 134830 : registerTask("check_copy_nodal_vars", true);
272 134830 : registerTask("copy_nodal_vars", true);
273 134830 : registerTask("copy_nodal_aux_vars", true);
274 134830 : registerTask("copy_vars_physics", false);
275 134830 : registerTask("setup_postprocessor_data", false);
276 134830 : registerTask("setup_time_steppers", true);
277 :
278 134830 : registerTask("setup_dampers", true);
279 134830 : registerTask("check_integrity", true);
280 134830 : registerTask("resolve_optional_materials", true);
281 134830 : registerTask("check_integrity_early", true);
282 134830 : registerTask("check_integrity_early_physics", false);
283 134830 : registerTask("setup_quadrature", true);
284 134830 : registerTask("create_tagged_matrices", true);
285 :
286 134830 : registerTask("mesh_modifiers", false);
287 :
288 : /// Additional Actions
289 134830 : registerTask("no_action", false); // Used for Empty Action placeholders
290 134830 : registerTask("set_global_params", false);
291 134830 : registerTask("setup_adaptivity", false);
292 134830 : registerTask("meta_action", false);
293 134830 : registerTask("setup_residual_debug", false);
294 134830 : registerTask("setup_oversampling", false);
295 134830 : registerTask("deprecated_block", false);
296 134830 : registerTask("set_adaptivity_options", false);
297 134830 : registerTask("add_mortar_interface", false);
298 134830 : registerTask("coupling_functor_check", true);
299 134830 : registerTask("add_master_action_material", false);
300 134830 : registerTask("setup_projected_properties", false);
301 134830 : registerTask("create_application_block", false);
302 :
303 : // Dummy Actions (useful for sync points in the dependencies)
304 134830 : registerTask("setup_function_complete", false);
305 134830 : registerTask("setup_variable_complete", false);
306 134830 : registerTask("setup_executioner_complete", false);
307 134830 : registerTask("ready_to_init", true);
308 :
309 : // Output related actions
310 134830 : registerTask("add_output_aux_variables", true);
311 134830 : registerTask("check_output", true);
312 134830 : registerTask("declare_late_reporters", true);
313 :
314 134830 : registerTask("create_problem_default", true);
315 134830 : registerTask("create_problem_custom", false);
316 134830 : registerTask("create_problem_complete", false);
317 :
318 134830 : registerTask("add_default_nonlinear_convergence", true);
319 134830 : registerTask("add_default_multiapp_fixed_point_convergence", true);
320 134830 : registerTask("add_default_steady_state_convergence", true);
321 :
322 134830 : registerTask("chain_control_setup", true);
323 134830 : registerTask("start_webservercontrol", true);
324 :
325 : // Action for setting up the signal-based checkpoint
326 134830 : 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 134830 : 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 101102 : registerTask("add_mfem_problem_operator", true);
458 202204 : addTaskDependency("add_mfem_problem_operator", "init_mesh");
459 202204 : addTaskDependency("add_variable", "add_mfem_problem_operator");
460 202204 : addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
461 202204 : addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
462 202204 : addTaskDependency("add_bc", "add_mfem_problem_operator");
463 202204 : addTaskDependency("add_kernel", "add_mfem_problem_operator");
464 :
465 : // add SubMeshes
466 202204 : registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
467 202204 : addTaskDependency("add_mfem_submeshes", "create_problem_complete");
468 :
469 : // add SubMesh transfers
470 202204 : appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
471 :
472 : // add FESpaces
473 202204 : registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
474 202204 : appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
475 202204 : addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
476 202204 : addTaskDependency("add_variable", "add_mfem_fespaces");
477 202204 : addTaskDependency("add_aux_variable", "add_mfem_fespaces");
478 202204 : addTaskDependency("add_elemental_field_variable", "add_mfem_fespaces");
479 202204 : addTaskDependency("add_kernel", "add_mfem_fespaces");
480 :
481 : // add complex kernels
482 202204 : registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
483 202204 : registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
484 202204 : addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
485 202204 : addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
486 202204 : addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
487 202204 : addTaskDependency("add_mfem_complex_bc_components", "add_bc");
488 :
489 : // set mesh FE space
490 101102 : registerTask("set_mesh_fe_space", true);
491 202204 : addTaskDependency("set_mesh_fe_space", "add_variable");
492 202204 : addTaskDependency("set_mesh_fe_space", "init_mesh");
493 :
494 : // add preconditioning.
495 202204 : registerMooseObjectTask("add_mfem_preconditioner", Moose::MFEM::SolverBase, false);
496 202204 : addTaskDependency("add_mfem_preconditioner", "add_mfem_problem_operator");
497 202204 : addTaskDependency("add_mfem_preconditioner", "add_variable");
498 :
499 : // add solver objects.
500 202204 : registerMooseObjectTask("add_mfem_solver", Moose::MFEM::SolverBase, true);
501 202204 : addTaskDependency("add_mfem_solver", "add_mfem_preconditioner");
502 202204 : addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
503 : #endif
504 :
505 : // Linear FV kernels fetch FVInterpolationMethod instances in their constructors
506 269660 : addTaskDependency("add_linear_fv_kernel", "add_interpolation_method");
507 :
508 134830 : registerTask("parse_neml2", /*required=*/false);
509 269660 : addTaskDependency("add_material", "parse_neml2");
510 202245 : addTaskDependency("add_user_object", "parse_neml2");
511 67415 : }
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 67415 : registerActions(Syntax & syntax,
550 : ActionFactory & action_factory,
551 : const std::set<std::string> & obj_labels)
552 : {
553 67415 : Registry::registerActionsTo(action_factory, obj_labels);
554 :
555 : // Add these actions here so they are always executed last, without setting any dependency
556 134830 : registerTask("dump_objects", false);
557 67415 : registerTask("finish_input_file_output", false);
558 67415 : }
559 :
560 : void
561 67415 : 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 539320 : registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
569 539320 : registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
570 :
571 539320 : registerSyntax("AddActionComponentAction", "ActionComponents/*");
572 539320 : registerSyntax("CombineComponentsMeshes", "ActionComponents");
573 :
574 539320 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
575 539320 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
576 539320 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
577 539320 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
578 :
579 539320 : registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
580 539320 : registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
581 539320 : registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
582 :
583 539320 : registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
584 :
585 539320 : registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
586 :
587 539320 : registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
588 539320 : registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
589 :
590 539320 : registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
591 :
592 539320 : registerSyntax("CreateProblemAction", "Problem");
593 539320 : registerSyntax("DynamicObjectRegistrationAction", "Problem");
594 :
595 539320 : registerSyntax("SetupMeshAction", "Mesh");
596 539320 : registerSyntax("SetupMeshCompleteAction", "Mesh");
597 : // Components should be able create a Mesh without a Mesh block
598 539320 : registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
599 539320 : registerSyntax("CreateDisplacedProblemAction", "Mesh");
600 539320 : registerSyntax("DisplayGhostingAction", "Mesh");
601 539320 : registerSyntax("AddMeshGeneratorAction", "Mesh/*");
602 539320 : registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
603 539320 : registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
604 539320 : registerSyntax("ElementIDOutputAction", "Mesh");
605 269660 : syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
606 :
607 539320 : registerSyntax("AddFunctionAction", "Functions/*");
608 269660 : syntax.registerSyntaxType("Functions/*", "FunctionName");
609 :
610 539320 : registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
611 269660 : syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
612 539320 : registerSyntax("AddConvergenceAction", "Convergence/*");
613 269660 : syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
614 :
615 539320 : registerSyntax("GlobalParamsAction", "GlobalParams");
616 :
617 539320 : registerSyntax("AddDistributionAction", "Distributions/*");
618 269660 : syntax.registerSyntaxType("Distributions/*", "DistributionName");
619 :
620 539320 : registerSyntax("AddSamplerAction", "Samplers/*");
621 269660 : syntax.registerSyntaxType("Samplers/*", "SamplerName");
622 :
623 539320 : registerSyntax("SetupDebugAction", "Debug");
624 539320 : registerSyntax("SetupResidualDebugAction", "Debug");
625 :
626 : /// Variable/AuxVariable Actions
627 539320 : registerSyntax("AddVariableAction", "Variables/*");
628 269660 : syntax.registerSyntaxType("Variables/*", "VariableName");
629 269660 : syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
630 :
631 539320 : registerSyntax("AddICAction", "Variables/*/InitialCondition");
632 539320 : registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
633 :
634 539320 : registerSyntax("AddAuxVariableAction", "AuxVariables/*");
635 269660 : syntax.registerSyntaxType("AuxVariables/*", "VariableName");
636 269660 : syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
637 :
638 539320 : registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
639 539320 : registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
640 :
641 539320 : registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
642 539320 : registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
643 :
644 539320 : registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
645 539320 : registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
646 :
647 539320 : registerSyntax("AddMaterialAction", "Materials/*");
648 269660 : syntax.registerSyntaxType("Materials/*", "MaterialName");
649 :
650 539320 : registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
651 269660 : syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
652 :
653 539320 : registerSyntax("AddPostprocessorAction", "Postprocessors/*");
654 269660 : syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
655 269660 : syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
656 :
657 539320 : registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
658 269660 : syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
659 :
660 539320 : registerSyntax("AddReporterAction", "Reporters/*");
661 269660 : syntax.registerSyntaxType("Reporters/*", "ReporterName");
662 :
663 539320 : registerSyntax("AddPositionsAction", "Positions/*");
664 269660 : syntax.registerSyntaxType("Positions/*", "PositionsName");
665 :
666 539320 : registerSyntax("AddTimesAction", "Times/*");
667 269660 : syntax.registerSyntaxType("Times/*", "TimesName");
668 :
669 539320 : registerSyntax("AddDamperAction", "Dampers/*");
670 :
671 539320 : registerSyntax("AddOutputAction", "Outputs/*");
672 539320 : registerSyntax("CommonOutputAction", "Outputs");
673 539320 : registerSyntax("MaterialOutputAction", "Outputs");
674 539320 : registerSyntax("AutoCheckpointAction", "Outputs");
675 269660 : syntax.registerSyntaxType("Outputs/*", "OutputName");
676 :
677 : // Note: Preconditioner Actions will be built by this setup action
678 539320 : registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
679 539320 : registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
680 :
681 539320 : registerSyntax("CreateExecutionerAction", "Executioner");
682 539320 : registerSyntax("ReadExecutorParamsAction", "Executors/*");
683 :
684 539320 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
685 539320 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
686 539320 : registerSyntaxTask(
687 : "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
688 539320 : registerSyntaxTask(
689 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
690 539320 : registerSyntaxTask(
691 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
692 269660 : syntax.registerSyntaxType("Executors/*", "ExecutorName");
693 :
694 539320 : registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
695 539320 : registerSyntax("SetupPredictorAction", "Executioner/Predictor");
696 : #ifdef LIBMESH_ENABLE_AMR
697 539320 : registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
698 : #endif
699 :
700 539320 : registerSyntax("PartitionerAction", "Mesh/Partitioner");
701 :
702 539320 : registerSyntax("AddDiracKernelAction", "DiracKernels/*");
703 :
704 539320 : registerSyntax("AddDGKernelAction", "DGKernels/*");
705 539320 : registerSyntax("AddFVKernelAction", "FVKernels/*");
706 539320 : registerSyntax("AddFVBCAction", "FVBCs/*");
707 539320 : registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
708 539320 : registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
709 539320 : registerSyntax("CheckFVBCAction", "FVBCs");
710 :
711 539320 : registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
712 :
713 539320 : registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
714 :
715 539320 : registerSyntax("AddConstraintAction", "Constraints/*");
716 :
717 539320 : registerSyntax("AddControlAction", "Controls/*");
718 539320 : registerSyntax("AddChainControlAction", "ChainControls/*");
719 539320 : registerSyntax("AddBoundAction", "Bounds/*");
720 539320 : registerSyntax("AddBoundsVectorsAction", "Bounds");
721 :
722 : // UserObject and some derived classes
723 539320 : registerSyntax("AddUserObjectAction", "UserObjects/*");
724 269660 : syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
725 :
726 539320 : registerSyntax("AddCorrectorAction", "Correctors/*");
727 269660 : syntax.registerSyntaxType("Correctors/*", "UserObjectName");
728 :
729 539320 : registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
730 269660 : syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
731 :
732 539320 : registerSyntax("AddNodalNormalsAction", "NodalNormals");
733 :
734 : // FVInterpolationMethods
735 539320 : registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
736 269660 : syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
737 :
738 : // Indicator
739 539320 : registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
740 539320 : registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
741 269660 : syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
742 :
743 : // Marker
744 539320 : registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
745 539320 : registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
746 269660 : syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
747 :
748 : // New Adaptivity System
749 539320 : registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
750 :
751 : // Deprecated Block
752 539320 : registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
753 :
754 : // Multi Apps
755 539320 : registerSyntax("AddMultiAppAction", "MultiApps/*");
756 269660 : syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
757 :
758 : // Transfers
759 539320 : registerSyntax("AddTransferAction", "Transfers/*");
760 :
761 : // Material derivative test
762 539320 : registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
763 539320 : registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
764 :
765 539320 : registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
766 :
767 : // Application Block System
768 539320 : registerSyntax("CreateApplicationBlockAction", "Application");
769 :
770 : #ifdef MOOSE_MFEM_ENABLED
771 404408 : registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
772 404408 : registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
773 404408 : registerSyntaxTask(
774 : "AddMFEMComplexKernelComponentAction", "Kernels/*/*", "add_mfem_complex_kernel_components");
775 404408 : registerSyntaxTask(
776 : "AddMFEMComplexBCComponentAction", "BCs/*/*", "add_mfem_complex_bc_components");
777 404408 : registerSyntaxTask("AddMFEMPreconditionerAction", "Preconditioner/*", "add_mfem_preconditioner");
778 404408 : registerSyntaxTask("AddMFEMSolverAction", "Solvers/*", "add_mfem_solver");
779 202204 : syntax.registerSyntaxType("Solvers/*", "MFEMSolverName");
780 : #endif
781 :
782 539320 : registerSyntax("NEML2ActionCommon", "NEML2");
783 471905 : registerSyntax("NEML2Action", "NEML2/*");
784 :
785 67415 : addActionTypes(syntax);
786 67415 : }
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 9756173 : colorConsole()
814 : {
815 9756173 : return _color_console;
816 : }
817 :
818 : bool
819 54855 : setColorConsole(bool use_color, bool force)
820 : {
821 54855 : _color_console = (isatty(fileno(stdout)) || force) && use_color;
822 54855 : return _color_console;
823 : }
824 :
825 2731736 : ScopedThrowOnError::ScopedThrowOnError(const bool throw_on_error)
826 2731736 : : _throw_on_error_before(Moose::_throw_on_error)
827 : {
828 : mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
829 2731736 : Moose::_throw_on_error = throw_on_error;
830 2731736 : }
831 :
832 2731736 : ScopedThrowOnError::ScopedThrowOnError() : ScopedThrowOnError(true) {}
833 :
834 2731736 : 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 16247 : hitMessagePrefix(const hit::Node & node)
852 : {
853 : // Strip meaningless line and column number for CLI args
854 16247 : if (node.filename() == "CLI_ARGS")
855 1264 : return "CLI_ARGS:\n";
856 : // If using the root node, don't add line info
857 15615 : if (node.isRoot())
858 3 : return node.filename() + ":\n";
859 15612 : 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
|
