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