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 <unistd.h>
26 :
27 : const ExecFlagType EXEC_NONE = registerDefaultExecFlag("NONE");
28 : const ExecFlagType EXEC_INITIAL = registerDefaultExecFlag("INITIAL");
29 : const ExecFlagType EXEC_LINEAR = registerDefaultExecFlag("LINEAR");
30 : const ExecFlagType EXEC_LINEAR_CONVERGENCE = registerDefaultExecFlag("LINEAR_CONVERGENCE");
31 : const ExecFlagType EXEC_NONLINEAR = registerDefaultExecFlag("NONLINEAR");
32 : const ExecFlagType EXEC_NONLINEAR_CONVERGENCE = registerDefaultExecFlag("NONLINEAR_CONVERGENCE");
33 : const ExecFlagType EXEC_POSTCHECK = registerDefaultExecFlag("POSTCHECK");
34 : const ExecFlagType EXEC_TIMESTEP_END = registerDefaultExecFlag("TIMESTEP_END");
35 : const ExecFlagType EXEC_TIMESTEP_BEGIN = registerDefaultExecFlag("TIMESTEP_BEGIN");
36 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END =
37 : registerDefaultExecFlag("MULTIAPP_FIXED_POINT_END");
38 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN =
39 : registerDefaultExecFlag("MULTIAPP_FIXED_POINT_BEGIN");
40 : const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE =
41 : registerDefaultExecFlag("MULTIAPP_FIXED_POINT_CONVERGENCE");
42 : const ExecFlagType EXEC_FINAL = registerDefaultExecFlag("FINAL");
43 : const ExecFlagType EXEC_FORCED = registerExecFlag("FORCED");
44 : const ExecFlagType EXEC_FAILED = registerExecFlag("FAILED");
45 : const ExecFlagType EXEC_CUSTOM = registerDefaultExecFlag("CUSTOM");
46 : const ExecFlagType EXEC_SUBDOMAIN = registerExecFlag("SUBDOMAIN");
47 : const ExecFlagType EXEC_ALWAYS = registerExecFlag("ALWAYS");
48 : const ExecFlagType EXEC_PRE_DISPLACE = registerExecFlag("PRE_DISPLACE");
49 : const ExecFlagType EXEC_SAME_AS_MULTIAPP = registerExecFlag("SAME_AS_MULTIAPP");
50 : const ExecFlagType EXEC_PRE_MULTIAPP_SETUP = registerExecFlag("PRE_MULTIAPP_SETUP");
51 : const ExecFlagType EXEC_TRANSFER = registerExecFlag("TRANSFER");
52 : const ExecFlagType EXEC_PRE_KERNELS = registerExecFlag("PRE_KERNELS");
53 : #ifdef LIBMESH_ENABLE_AMR
54 : const ExecFlagType EXEC_POST_ADAPTIVITY = registerExecFlag("POST_ADAPTIVITY");
55 : #endif
56 :
57 : namespace Moose
58 : {
59 :
60 : void associateSyntaxInner(Syntax & syntax, ActionFactory & action_factory);
61 :
62 : void
63 62754 : registerAll(Factory & f, ActionFactory & af, Syntax & s)
64 : {
65 125508 : registerObjects(f, {"MooseApp"});
66 62754 : associateSyntaxInner(s, af);
67 125508 : registerActions(s, af, {"MooseApp"});
68 62754 : registerAppDataFilePath("moose");
69 62754 : registerRepository("moose", "github.com/idaholab/moose");
70 251016 : }
71 :
72 : void
73 62754 : registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
74 : {
75 62754 : Registry::registerObjectsTo(factory, obj_labels);
76 62754 : }
77 :
78 : void
79 62754 : addActionTypes(Syntax & syntax)
80 : {
81 : /**
82 : * The (optional) last param here indicates whether the task should trigger an Action auto-build.
83 : * If a task is marked as "true". Then MOOSE will attempt to build the associated Action if one is
84 : * not supplied by some other means (usually through the input file or custom Action). Only
85 : * Actions that do not have required parameters and have defaults for all optional parameters can
86 : * be built automatically (See ActionWarehouse.C).
87 : *
88 : * Note: Many of the actions in the "Minimal Problem" section are marked as false. However, we
89 : * can generally force creation of these "Action"s as needed by registering them to syntax that we
90 : * expect to see even if those "Action"s don't normally pick up parameters from the input file.
91 : */
92 :
93 : // clang-format off
94 : /**************************/
95 : /**** Register Actions ****/
96 : /**************************/
97 62754 : registerMooseObjectTask("create_problem", Problem, false);
98 62754 : registerMooseObjectTask("setup_executioner", Executioner, false);
99 62754 : registerMooseObjectTask("read_executor", Executor, false);
100 62754 : registerTask("add_executor", true);
101 :
102 : // TODO Organize these somewhere
103 62754 : registerTask("init_physics", false);
104 62754 : registerTask("init_component_physics", false);
105 62754 : registerTask("meta_action_component", false);
106 62754 : registerTask("setup_component", false);
107 : // 'list_component' is used to retrieve ActionComponents for the syntax JSON
108 62754 : registerTask("list_component", false);
109 :
110 : // This task does not construct an object, but it needs all of the parameters that
111 : // would normally be used to construct an object.
112 62754 : registerMooseObjectTask("determine_system_type", Executioner, true);
113 :
114 62754 : registerMooseObjectTask("setup_mesh", MooseMesh, false);
115 62754 : registerMooseObjectTask("set_mesh_base", MooseMesh, false);
116 62754 : registerMooseObjectTask("init_mesh", MooseMesh, false);
117 62754 : registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
118 62754 : registerTask("create_added_mesh_generators", true);
119 62754 : registerMooseObjectTask("append_mesh_generator", MeshGenerator, false);
120 :
121 62754 : registerMooseObjectTask("add_kernel", Kernel, false);
122 62754 : appendMooseObjectTask ("add_kernel", EigenKernel);
123 62754 : appendMooseObjectTask ("add_kernel", VectorKernel);
124 62754 : appendMooseObjectTask ("add_kernel", ArrayKernel);
125 :
126 62754 : registerMooseObjectTask("add_variable", MooseVariableBase, false);
127 62754 : registerMooseObjectTask("add_aux_variable", MooseVariableBase, false);
128 62754 : registerMooseObjectTask("add_elemental_field_variable", MooseVariableBase, false);
129 :
130 62754 : registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
131 :
132 62754 : registerMooseObjectTask("add_functor_material", FunctorMaterial, false);
133 62754 : registerMooseObjectTask("add_material", MaterialBase, false);
134 62754 : appendDeprecatedMooseObjectTask("add_material", FunctorMaterial);
135 62754 : registerMooseObjectTask("add_bc", BoundaryCondition, false);
136 :
137 62754 : registerMooseObjectTask("add_function", Function, false);
138 62754 : registerMooseObjectTask("add_distribution", Distribution, false);
139 62754 : registerMooseObjectTask("add_sampler", Sampler, false);
140 :
141 62754 : registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
142 62754 : appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
143 62754 : appendMooseObjectTask ("add_aux_kernel", ArrayAuxKernel);
144 62754 : registerMooseObjectTask("add_bound", Bounds, false);
145 :
146 62754 : registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
147 62754 : registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
148 62754 : registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
149 62754 : appendMooseObjectTask ("add_dirac_kernel", VectorDiracKernel);
150 62754 : registerMooseObjectTask("add_dg_kernel", DGKernel, false);
151 62754 : registerMooseObjectTask("add_fv_kernel", FVKernel, false);
152 62754 : registerMooseObjectTask("add_linear_fv_kernel", LinearFVKernel, false);
153 62754 : registerMooseObjectTask("add_fv_bc", FVBoundaryCondition, false);
154 62754 : registerMooseObjectTask("add_linear_fv_bc", LinearFVBoundaryCondition, false);
155 62754 : registerMooseObjectTask("add_fv_ik", FVInterfaceKernel, false);
156 62754 : registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
157 62754 : appendMooseObjectTask ("add_interface_kernel", VectorInterfaceKernel);
158 62754 : registerMooseObjectTask("add_constraint", Constraint, false);
159 62754 : registerMooseObjectTask("add_hybridized_kernel", HDGKernel, false);
160 62754 : registerMooseObjectTask("add_hybridized_integrated_bc", HDGIntegratedBC, false);
161 :
162 62754 : registerMooseObjectTask("add_ic", InitialCondition, false);
163 62754 : appendMooseObjectTask ("add_ic", ScalarInitialCondition);
164 :
165 62754 : registerMooseObjectTask("add_fv_ic", FVInitialCondition, false);
166 :
167 62754 : registerMooseObjectTask("add_damper", Damper, false);
168 62754 : registerMooseObjectTask("setup_predictor", Predictor, false);
169 62754 : registerMooseObjectTask("add_time_steppers", TimeStepper, false);
170 62754 : registerMooseObjectTask("add_time_stepper", TimeStepper, false);
171 62754 : registerTask ("compose_time_stepper", true);
172 62754 : registerMooseObjectTask("setup_time_integrators", TimeIntegrator, false);
173 62754 : registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
174 62754 : registerMooseObjectTask("add_convergence", Convergence, false);
175 :
176 62754 : registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
177 62754 : registerMooseObjectTask("add_field_split", Split, false);
178 :
179 62754 : registerMooseObjectTask("add_mesh_division", MeshDivision, false);
180 62754 : registerMooseObjectTask("add_user_object", UserObject, false);
181 62754 : appendMooseObjectTask ("add_user_object", Postprocessor);
182 62754 : appendDeprecatedMooseObjectTask("add_user_object", Corrector);
183 62754 : registerMooseObjectTask("add_corrector", Corrector, false);
184 62754 : appendDeprecatedMooseObjectTask("add_user_object", MeshModifier);
185 62754 : registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
186 :
187 62754 : registerMooseObjectTask("add_postprocessor", Postprocessor, false);
188 62754 : registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
189 62754 : registerMooseObjectTask("add_reporter", Reporter, false);
190 62754 : registerMooseObjectTask("add_positions", Positions, false);
191 62754 : registerMooseObjectTask("add_times", Times, false);
192 :
193 62754 : registerMooseObjectTask("add_indicator", Indicator, false);
194 62754 : registerMooseObjectTask("add_marker", Marker, false);
195 :
196 62754 : registerMooseObjectTask("add_multi_app", MultiApp, false);
197 62754 : registerMooseObjectTask("add_transfer", Transfer, false);
198 :
199 62754 : registerMooseObjectTask("add_output", Output, false);
200 :
201 62754 : registerMooseObjectTask("add_control", Control, false);
202 62754 : registerMooseObjectTask("add_chain_control", ChainControl, false);
203 62754 : registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
204 :
205 : // clang-format on
206 :
207 62754 : registerTask("dynamic_object_registration", false);
208 62754 : registerTask("common_output", true);
209 62754 : registerTask("setup_recover_file_base", true);
210 62754 : registerTask("recover_meta_data", true);
211 :
212 62754 : registerTask("add_bounds_vectors", false);
213 62754 : registerTask("add_periodic_bc", false);
214 62754 : registerTask("add_aux_variable", false);
215 62754 : registerTask("add_external_aux_variables", true);
216 62754 : registerTask("add_variable", false);
217 62754 : registerTask("add_mortar_variable", false);
218 :
219 62754 : registerTask("execute_mesh_generators", true);
220 62754 : registerTask("uniform_refine_mesh", false);
221 62754 : registerTask("prepare_mesh", false);
222 62754 : registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
223 62754 : registerTask("setup_mesh_complete", true); // calls prepare
224 62754 : registerTask("post_mesh_prepared", false);
225 62754 : registerTask("add_geometric_rm", false);
226 62754 : registerTask("attach_geometric_rm", true);
227 62754 : registerTask("attach_geometric_rm_final", true);
228 :
229 62754 : registerTask("init_displaced_problem", false);
230 :
231 62754 : registerTask("add_algebraic_rm", false);
232 62754 : registerTask("attach_algebraic_rm", true);
233 62754 : registerTask("add_coupling_rm", false);
234 62754 : registerTask("attach_coupling_rm", true);
235 62754 : registerTask("init_problem", true);
236 62754 : registerTask("check_copy_nodal_vars", true);
237 62754 : registerTask("copy_nodal_vars", true);
238 62754 : registerTask("copy_nodal_aux_vars", true);
239 62754 : registerTask("copy_vars_physics", false);
240 62754 : registerTask("setup_postprocessor_data", false);
241 62754 : registerTask("setup_time_steppers", true);
242 :
243 62754 : registerTask("setup_dampers", true);
244 62754 : registerTask("check_integrity", true);
245 62754 : registerTask("resolve_optional_materials", true);
246 62754 : registerTask("check_integrity_early", true);
247 62754 : registerTask("check_integrity_early_physics", false);
248 62754 : registerTask("setup_quadrature", true);
249 :
250 62754 : registerTask("mesh_modifiers", false);
251 :
252 : /// Additional Actions
253 62754 : registerTask("no_action", false); // Used for Empty Action placeholders
254 62754 : registerTask("set_global_params", false);
255 62754 : registerTask("setup_adaptivity", false);
256 62754 : registerTask("meta_action", false);
257 62754 : registerTask("setup_residual_debug", false);
258 62754 : registerTask("setup_oversampling", false);
259 62754 : registerTask("deprecated_block", false);
260 62754 : registerTask("set_adaptivity_options", false);
261 62754 : registerTask("add_mortar_interface", false);
262 62754 : registerTask("coupling_functor_check", true);
263 62754 : registerTask("add_master_action_material", false);
264 62754 : registerTask("setup_projected_properties", false);
265 62754 : registerTask("create_application_block", false);
266 :
267 : // Dummy Actions (useful for sync points in the dependencies)
268 62754 : registerTask("setup_function_complete", false);
269 62754 : registerTask("setup_variable_complete", false);
270 62754 : registerTask("setup_executioner_complete", false);
271 62754 : registerTask("ready_to_init", true);
272 :
273 : // Output related actions
274 62754 : registerTask("add_output_aux_variables", true);
275 62754 : registerTask("check_output", true);
276 62754 : registerTask("declare_late_reporters", true);
277 :
278 62754 : registerTask("create_problem_default", true);
279 62754 : registerTask("create_problem_custom", false);
280 62754 : registerTask("create_problem_complete", false);
281 :
282 62754 : registerTask("add_default_nonlinear_convergence", true);
283 62754 : registerTask("add_default_multiapp_fixed_point_convergence", true);
284 :
285 62754 : registerTask("chain_control_setup", true);
286 :
287 : // Action for setting up the signal-based checkpoint
288 62754 : registerTask("auto_checkpoint_action", true);
289 : /**************************/
290 : /****** Dependencies ******/
291 : /**************************/
292 : /**
293 : * The following is the default set of action dependencies for a basic MOOSE problem. The
294 : * formatting of this string is important. Each line represents a set of dependencies that depend
295 : * on the previous line. Items on the same line have equal weight and can be executed in any
296 : * order.
297 : *
298 : * Additional dependencies can be inserted later inside of user applications with calls to
299 : * ActionWarehouse::addDependency("task", "pre_req")
300 : */
301 :
302 : // clang-format off
303 62754 : syntax.addDependencySets("(meta_action)"
304 : "(meta_action_component)"
305 : "(dynamic_object_registration)"
306 : "(common_output)"
307 : "(set_global_params)"
308 : "(setup_recover_file_base)"
309 : "(check_copy_nodal_vars)"
310 : "(setup_mesh)"
311 : "(add_geometric_rm)"
312 : "(add_partitioner)"
313 : "(add_mesh_generator)"
314 : "(create_added_mesh_generators)"
315 : "(append_mesh_generator)"
316 : "(execute_mesh_generators)"
317 : "(recover_meta_data)"
318 : "(set_mesh_base)"
319 : "(attach_geometric_rm)"
320 : "(init_mesh)"
321 : "(prepare_mesh)"
322 : "(add_mortar_interface)"
323 : "(uniform_refine_mesh)"
324 : "(setup_mesh_complete)"
325 : "(post_mesh_prepared)"
326 : "(determine_system_type)"
327 : "(create_problem)"
328 : "(create_problem_custom)"
329 : "(create_problem_default)"
330 : "(create_problem_complete)"
331 : "(init_displaced_problem)" // Problem must be init-ed before we start adding functors
332 : "(add_function)" // Functions can depend on scalar variables & PPs, but this dependence can be
333 : // added on initialSetup() rather than construction
334 : "(init_component_physics)" // components must add their blocks to physics before init_physics
335 : "(init_physics)"
336 : "(setup_postprocessor_data)"
337 : "(setup_time_integrator, setup_time_integrators)"
338 : "(setup_executioner)"
339 : "(setup_executioner_complete)"
340 : "(setup_component)" // no particular reason for that placement
341 : "(read_executor)"
342 : "(add_executor)"
343 : "(check_integrity_early)"
344 : "(setup_predictor)"
345 : "(add_aux_variable, add_variable, add_elemental_field_variable,"
346 : " add_external_aux_variables)"
347 : "(add_mortar_variable)"
348 : "(setup_variable_complete)"
349 : "(check_integrity_early_physics)" // checks that systems and variables are consistent
350 : "(setup_quadrature)"
351 : "(add_convergence)"
352 : "(add_default_nonlinear_convergence,"
353 : " add_default_multiapp_fixed_point_convergence)"
354 : "(add_periodic_bc)"
355 : "(add_user_object, add_corrector, add_mesh_modifier)"
356 : "(add_distribution)"
357 : "(add_sampler)"
358 : "(setup_function_complete)"
359 : "(setup_adaptivity)"
360 : "(set_adaptivity_options)"
361 : "(add_ic, add_fv_ic)"
362 : "(add_constraint, add_field_split)"
363 : "(add_preconditioning)"
364 : "(add_times)"
365 : "(add_time_stepper, add_time_steppers)"
366 : "(compose_time_stepper)"
367 : "(setup_time_steppers)"
368 : "(ready_to_init)"
369 : "(setup_dampers)"
370 : "(setup_residual_debug)"
371 : "(add_bounds_vectors)"
372 : "(add_positions)"
373 : "(add_mesh_division)" // NearestPositionsDivision uses a Positions
374 : "(add_multi_app)"
375 : "(add_transfer)"
376 : "(copy_nodal_vars, copy_nodal_aux_vars, copy_vars_physics)"
377 : "(add_material)"
378 : "(add_master_action_material)"
379 : "(add_functor_material)"
380 : "(setup_projected_properties)"
381 : "(add_output_aux_variables)"
382 : "(add_output)"
383 : "(auto_checkpoint_action)"
384 : "(add_postprocessor)"
385 : "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
386 : // to be after material objects are created.
387 : "(add_reporter)"
388 : "(declare_late_reporters)"
389 : "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
390 : " add_nodal_kernel, add_dg_kernel, add_fv_kernel, add_linear_fv_kernel,"
391 : " add_fv_bc, add_linear_fv_bc, add_fv_ik, add_interface_kernel,"
392 : " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker,"
393 : " add_bound, add_hybridized_kernel, add_hybridized_integrated_bc)"
394 : "(resolve_optional_materials)"
395 : "(add_algebraic_rm)"
396 : "(add_coupling_rm)"
397 : "(attach_geometric_rm_final)"
398 : "(attach_algebraic_rm)"
399 : "(attach_coupling_rm)"
400 : "(coupling_functor_check)"
401 : "(delete_remote_elements_after_late_geometric_ghosting)"
402 : "(init_problem)"
403 : "(add_control, add_chain_control)"
404 : "(chain_control_setup)"
405 : "(check_output)"
406 : "(check_integrity)"
407 : "(create_application_block)");
408 : // clang-format on
409 :
410 : #ifdef MOOSE_MFEM_ENABLED
411 39589 : registerTask("add_mfem_problem_operator", true);
412 39589 : addTaskDependency("add_mfem_problem_operator", "init_mesh");
413 39589 : addTaskDependency("add_variable", "add_mfem_problem_operator");
414 39589 : addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
415 39589 : addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
416 39589 : addTaskDependency("add_kernel", "add_mfem_problem_operator");
417 :
418 : // add SubMeshes
419 39589 : registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
420 39589 : addTaskDependency("add_mfem_submeshes", "create_problem_complete");
421 :
422 : // add SubMesh transfers
423 39589 : appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
424 :
425 : // add FESpaces
426 39589 : registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
427 39589 : appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
428 39589 : addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
429 39589 : addTaskDependency("add_variable", "add_mfem_fespaces");
430 39589 : addTaskDependency("add_aux_variable", "add_mfem_fespaces");
431 39589 : addTaskDependency("add_elemental_field_variable", "add_mfem_fespaces");
432 39589 : addTaskDependency("add_kernel", "add_mfem_fespaces");
433 :
434 : // set mesh FE space
435 39589 : registerTask("set_mesh_fe_space", true);
436 39589 : addTaskDependency("set_mesh_fe_space", "add_variable");
437 39589 : addTaskDependency("set_mesh_fe_space", "init_mesh");
438 :
439 : // add preconditioning.
440 39589 : registerMooseObjectTask("add_mfem_preconditioner", MFEMSolverBase, false);
441 39589 : addTaskDependency("add_mfem_preconditioner", "add_mfem_problem_operator");
442 39589 : addTaskDependency("add_mfem_preconditioner", "add_variable");
443 :
444 : // add solver.
445 39589 : registerMooseObjectTask("add_mfem_solver", MFEMSolverBase, true);
446 39589 : addTaskDependency("add_mfem_solver", "add_mfem_preconditioner");
447 39589 : addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
448 : #endif
449 :
450 62754 : registerTask("parse_neml2", /*required=*/false);
451 62754 : addTaskDependency("add_material", "parse_neml2");
452 62754 : addTaskDependency("add_user_object", "parse_neml2");
453 62754 : }
454 :
455 : /**
456 : * Multiple Action class can be associated with a single input file section, in which case all
457 : * associated Actions will be created and "acted" on when the associated input file section is
458 : * seen.*
459 : *
460 : * Example:
461 : * "setup_mesh" <-----------> SetupMeshAction <---------
462 : * \
463 : * [Mesh]
464 : * /
465 : * "setup_mesh_complete" <---> SetupMeshCompleteAction <-
466 : *
467 : *
468 : * Action classes can also be registered to act on more than one input file section for a different
469 : * task if similar logic can work in multiple cases
470 : *
471 : * Example:
472 : * "add_variable" <----- -> [Variables/ *]
473 : * \ /
474 : * CopyNodalVarsAction
475 : * / \
476 : * "add_aux_variable" <- -> [AuxVariables/ *]
477 : *
478 : *
479 : * Note: Placeholder "no_action" actions must be put in places where it is possible to match an
480 : * object with a star or a more specific parent later on. (i.e. where one needs to negate the
481 : * '*' matching prematurely).
482 : */
483 : void
484 0 : registerActions(Syntax & syntax, ActionFactory & action_factory)
485 : {
486 0 : mooseDeprecated("use registerAll instead of registerActions");
487 0 : registerActions(syntax, action_factory, {"MooseApp"});
488 0 : }
489 :
490 : void
491 62754 : registerActions(Syntax & syntax,
492 : ActionFactory & action_factory,
493 : const std::set<std::string> & obj_labels)
494 : {
495 62754 : Registry::registerActionsTo(action_factory, obj_labels);
496 :
497 : // Add these actions here so they are always executed last, without setting any dependency
498 62754 : registerTask("dump_objects", false);
499 62754 : registerTask("finish_input_file_output", false);
500 62754 : }
501 :
502 : void
503 62754 : associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
504 : {
505 : /**
506 : * Note: the optional third parameter is used to differentiate which task is
507 : * satisfied based on the syntax encountered for classes which are registered
508 : * to satisfy more than one task
509 : */
510 62754 : registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
511 62754 : registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
512 :
513 62754 : registerSyntax("AddActionComponentAction", "ActionComponents/*");
514 62754 : registerSyntax("CombineComponentsMeshes", "ActionComponents");
515 :
516 62754 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
517 62754 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
518 62754 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
519 62754 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
520 :
521 62754 : registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
522 62754 : registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
523 62754 : registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
524 :
525 62754 : registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
526 :
527 62754 : registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
528 :
529 62754 : registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
530 62754 : registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
531 :
532 62754 : registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
533 :
534 62754 : registerSyntax("CreateProblemAction", "Problem");
535 62754 : registerSyntax("DynamicObjectRegistrationAction", "Problem");
536 :
537 62754 : registerSyntax("SetupMeshAction", "Mesh");
538 62754 : registerSyntax("SetupMeshCompleteAction", "Mesh");
539 : // Components should be able create a Mesh without a Mesh block
540 62754 : registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
541 62754 : registerSyntax("CreateDisplacedProblemAction", "Mesh");
542 62754 : registerSyntax("DisplayGhostingAction", "Mesh");
543 62754 : registerSyntax("AddMeshGeneratorAction", "Mesh/*");
544 62754 : registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
545 62754 : registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
546 62754 : registerSyntax("ElementIDOutputAction", "Mesh");
547 62754 : syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
548 :
549 62754 : registerSyntax("AddFunctionAction", "Functions/*");
550 62754 : syntax.registerSyntaxType("Functions/*", "FunctionName");
551 :
552 62754 : registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
553 62754 : syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
554 62754 : registerSyntax("AddConvergenceAction", "Convergence/*");
555 62754 : syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
556 :
557 62754 : registerSyntax("GlobalParamsAction", "GlobalParams");
558 :
559 62754 : registerSyntax("AddDistributionAction", "Distributions/*");
560 62754 : syntax.registerSyntaxType("Distributions/*", "DistributionName");
561 :
562 62754 : registerSyntax("AddSamplerAction", "Samplers/*");
563 62754 : syntax.registerSyntaxType("Samplers/*", "SamplerName");
564 :
565 62754 : registerSyntax("SetupDebugAction", "Debug");
566 62754 : registerSyntax("SetupResidualDebugAction", "Debug");
567 :
568 : /// Variable/AuxVariable Actions
569 62754 : registerSyntax("AddVariableAction", "Variables/*");
570 62754 : syntax.registerSyntaxType("Variables/*", "VariableName");
571 62754 : syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
572 :
573 62754 : registerSyntax("AddICAction", "Variables/*/InitialCondition");
574 62754 : registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
575 :
576 62754 : registerSyntax("AddAuxVariableAction", "AuxVariables/*");
577 62754 : syntax.registerSyntaxType("AuxVariables/*", "VariableName");
578 62754 : syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
579 :
580 62754 : registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
581 62754 : registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
582 :
583 62754 : registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
584 62754 : registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
585 :
586 62754 : registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
587 62754 : registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
588 :
589 62754 : registerSyntax("AddMaterialAction", "Materials/*");
590 62754 : syntax.registerSyntaxType("Materials/*", "MaterialName");
591 :
592 62754 : registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
593 62754 : syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
594 :
595 62754 : registerSyntax("AddPostprocessorAction", "Postprocessors/*");
596 62754 : syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
597 62754 : syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
598 :
599 62754 : registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
600 62754 : syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
601 :
602 62754 : registerSyntax("AddReporterAction", "Reporters/*");
603 62754 : syntax.registerSyntaxType("Reporters/*", "ReporterName");
604 :
605 62754 : registerSyntax("AddPositionsAction", "Positions/*");
606 62754 : syntax.registerSyntaxType("Positions/*", "PositionsName");
607 :
608 62754 : registerSyntax("AddTimesAction", "Times/*");
609 62754 : syntax.registerSyntaxType("Times/*", "TimesName");
610 :
611 62754 : registerSyntax("AddDamperAction", "Dampers/*");
612 :
613 62754 : registerSyntax("AddOutputAction", "Outputs/*");
614 62754 : registerSyntax("CommonOutputAction", "Outputs");
615 62754 : registerSyntax("MaterialOutputAction", "Outputs");
616 62754 : registerSyntax("AutoCheckpointAction", "Outputs");
617 62754 : syntax.registerSyntaxType("Outputs/*", "OutputName");
618 :
619 : // Note: Preconditioner Actions will be built by this setup action
620 62754 : registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
621 62754 : registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
622 :
623 62754 : registerSyntax("CreateExecutionerAction", "Executioner");
624 62754 : registerSyntax("ReadExecutorParamsAction", "Executors/*");
625 :
626 62754 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
627 62754 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
628 62754 : registerSyntaxTask(
629 : "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
630 62754 : registerSyntaxTask(
631 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
632 62754 : registerSyntaxTask(
633 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
634 62754 : syntax.registerSyntaxType("Executors/*", "ExecutorName");
635 :
636 62754 : registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
637 62754 : registerSyntax("SetupPredictorAction", "Executioner/Predictor");
638 : #ifdef LIBMESH_ENABLE_AMR
639 62754 : registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
640 : #endif
641 :
642 62754 : registerSyntax("PartitionerAction", "Mesh/Partitioner");
643 :
644 62754 : registerSyntax("AddDiracKernelAction", "DiracKernels/*");
645 :
646 62754 : registerSyntax("AddDGKernelAction", "DGKernels/*");
647 62754 : registerSyntax("AddFVKernelAction", "FVKernels/*");
648 62754 : registerSyntax("AddFVBCAction", "FVBCs/*");
649 62754 : registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
650 62754 : registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
651 62754 : registerSyntax("CheckFVBCAction", "FVBCs");
652 :
653 62754 : registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
654 :
655 62754 : registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
656 :
657 62754 : registerSyntax("AddConstraintAction", "Constraints/*");
658 :
659 62754 : registerSyntax("AddControlAction", "Controls/*");
660 62754 : registerSyntax("AddChainControlAction", "ChainControls/*");
661 62754 : registerSyntax("AddBoundAction", "Bounds/*");
662 62754 : registerSyntax("AddBoundsVectorsAction", "Bounds");
663 :
664 : // UserObject and some derived classes
665 62754 : registerSyntax("AddUserObjectAction", "UserObjects/*");
666 62754 : syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
667 62754 : registerSyntax("AddCorrectorAction", "Correctors/*");
668 62754 : syntax.registerSyntaxType("Correctors/*", "UserObjectName");
669 62754 : registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
670 62754 : syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
671 :
672 62754 : registerSyntax("AddNodalNormalsAction", "NodalNormals");
673 :
674 : // Indicator
675 62754 : registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
676 62754 : registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
677 62754 : syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
678 :
679 : // Marker
680 62754 : registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
681 62754 : registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
682 62754 : syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
683 :
684 : // New Adaptivity System
685 62754 : registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
686 :
687 : // Deprecated Block
688 62754 : registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
689 :
690 : // Multi Apps
691 62754 : registerSyntax("AddMultiAppAction", "MultiApps/*");
692 62754 : syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
693 :
694 : // Transfers
695 62754 : registerSyntax("AddTransferAction", "Transfers/*");
696 :
697 : // Material derivative test
698 62754 : registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
699 62754 : registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
700 :
701 62754 : registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
702 :
703 : // Application Block System
704 62754 : registerSyntax("CreateApplicationBlockAction", "Application");
705 :
706 : #ifdef MOOSE_MFEM_ENABLED
707 39589 : registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
708 39589 : registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
709 39589 : registerSyntaxTask("AddMFEMPreconditionerAction", "Preconditioner/*", "add_mfem_preconditioner");
710 39589 : registerSyntaxTask("AddMFEMSolverAction", "Solver", "add_mfem_solver");
711 : #endif
712 :
713 62754 : registerSyntax("NEML2ActionCommon", "NEML2");
714 62754 : registerSyntax("NEML2Action", "NEML2/*");
715 :
716 62754 : addActionTypes(syntax);
717 62754 : }
718 :
719 : void
720 0 : associateSyntax(Syntax & syntax, ActionFactory & action_factory)
721 : {
722 0 : associateSyntaxInner(syntax, action_factory);
723 0 : registerActions(syntax, action_factory);
724 0 : }
725 :
726 : void
727 0 : setSolverDefaults(FEProblemBase & problem)
728 : {
729 : // May be a touch expensive to create a new DM every time, but probably safer to do it this way
730 0 : Moose::PetscSupport::petscSetDefaults(problem);
731 0 : }
732 :
733 : MPI_Comm
734 1089753 : swapLibMeshComm(MPI_Comm new_comm)
735 : {
736 1089753 : MPI_Comm old_comm = PETSC_COMM_WORLD;
737 1089753 : PETSC_COMM_WORLD = new_comm;
738 1089753 : return old_comm;
739 : }
740 :
741 : static bool _color_console = isatty(fileno(stdout));
742 :
743 : bool
744 10842681 : colorConsole()
745 : {
746 10842681 : return _color_console;
747 : }
748 :
749 : bool
750 51326 : setColorConsole(bool use_color, bool force)
751 : {
752 51326 : _color_console = (isatty(fileno(stdout)) || force) && use_color;
753 51326 : return _color_console;
754 : }
755 :
756 : bool _warnings_are_errors = false;
757 : bool _deprecated_is_error = false;
758 : bool _throw_on_error = false;
759 : bool _throw_on_warning = false;
760 : int interrupt_signal_number = 0;
761 : bool show_trace = true;
762 : bool show_multiple = false;
763 :
764 : } // namespace Moose
|
