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