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 68461 : registerAll(Factory & f, ActionFactory & af, Syntax & s)
70 : {
71 68461 : registerObjects(f, {"MooseApp"});
72 68461 : associateSyntaxInner(s, af);
73 68461 : registerActions(s, af, {"MooseApp"});
74 273844 : registerAppDataFilePath("moose");
75 273844 : 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 410766 : 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 393768 : 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 257315 : 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 68461 : }
130 :
131 : void
132 68461 : registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
133 : {
134 68461 : Registry::registerObjectsTo(factory, obj_labels);
135 68461 : }
136 :
137 : void
138 68461 : 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 273844 : registerMooseObjectTask("create_problem", Problem, false);
157 273844 : registerMooseObjectTask("setup_executioner", Executioner, false);
158 273844 : registerMooseObjectTask("read_executor", Executor, false);
159 136922 : registerTask("add_executor", true);
160 :
161 : // TODO Organize these somewhere
162 136922 : registerTask("init_physics", false);
163 136922 : registerTask("init_component_physics", false);
164 136922 : registerTask("meta_action_component", false);
165 136922 : registerTask("setup_component", false);
166 : // 'list_component' is used to retrieve ActionComponents for the syntax JSON
167 136922 : 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 273844 : registerMooseObjectTask("determine_system_type", Executioner, true);
172 :
173 273844 : registerMooseObjectTask("setup_mesh", MooseMesh, false);
174 273844 : registerMooseObjectTask("set_mesh_base", MooseMesh, false);
175 273844 : registerMooseObjectTask("init_mesh", MooseMesh, false);
176 273844 : registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
177 136922 : registerTask("create_added_mesh_generators", true);
178 273844 : registerMooseObjectTask("append_mesh_generator", MeshGenerator, false);
179 :
180 273844 : registerMooseObjectTask("add_kernel", Kernel, false);
181 273844 : appendMooseObjectTask ("add_kernel", EigenKernel);
182 273844 : appendMooseObjectTask ("add_kernel", VectorKernel);
183 273844 : appendMooseObjectTask ("add_kernel", ArrayKernel);
184 273844 : appendMooseObjectTask ("add_kernel", ADArrayKernel);
185 :
186 273844 : registerMooseObjectTask("add_variable", MooseVariableBase, false);
187 273844 : registerMooseObjectTask("add_aux_variable", MooseVariableBase, false);
188 273844 : registerMooseObjectTask("add_elemental_field_variable", MooseVariableBase, false);
189 273844 : registerMooseObjectTask("add_variables_physics", MooseVariableBase, false);
190 :
191 273844 : registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
192 :
193 273844 : registerMooseObjectTask("add_functor_material", FunctorMaterial, false);
194 273844 : registerMooseObjectTask("add_material", MaterialBase, false);
195 273844 : appendDeprecatedMooseObjectTask("add_material", FunctorMaterial);
196 273844 : registerMooseObjectTask("add_materials_physics", FunctorMaterial, false);
197 273844 : appendMooseObjectTask ("add_materials_physics", MaterialBase);
198 :
199 273844 : registerMooseObjectTask("add_bc", BoundaryCondition, false);
200 :
201 273844 : registerMooseObjectTask("add_function", Function, false);
202 :
203 273844 : registerMooseObjectTask("add_distribution", Distribution, false);
204 273844 : registerMooseObjectTask("add_sampler", Sampler, false);
205 :
206 273844 : registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
207 273844 : appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
208 273844 : appendMooseObjectTask ("add_aux_kernel", ArrayAuxKernel);
209 :
210 273844 : registerMooseObjectTask("add_bound", Bounds, false);
211 :
212 273844 : registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
213 273844 : registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
214 273844 : registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
215 273844 : appendMooseObjectTask ("add_dirac_kernel", VectorDiracKernel);
216 273844 : registerMooseObjectTask("add_dg_kernel", DGKernel, false);
217 273844 : registerMooseObjectTask("add_fv_kernel", FVKernel, false);
218 273844 : registerMooseObjectTask("add_interpolation_method", FVInterpolationMethod, false);
219 273844 : registerMooseObjectTask("add_interpolation_method_physics", FVInterpolationMethod, false);
220 273844 : registerMooseObjectTask("add_linear_fv_kernel", LinearFVKernel, false);
221 273844 : registerMooseObjectTask("add_fv_bc", FVBoundaryCondition, false);
222 273844 : registerMooseObjectTask("add_linear_fv_bc", LinearFVBoundaryCondition, false);
223 273844 : registerMooseObjectTask("add_fv_ik", FVInterfaceKernel, false);
224 273844 : registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
225 273844 : appendMooseObjectTask ("add_interface_kernel", VectorInterfaceKernel);
226 273844 : registerMooseObjectTask("add_constraint", Constraint, false);
227 273844 : registerMooseObjectTask("add_hybridized_kernel", HDGKernel, false);
228 273844 : registerMooseObjectTask("add_hybridized_integrated_bc", HDGIntegratedBC, false);
229 :
230 273844 : registerMooseObjectTask("add_ic", InitialCondition, false);
231 273844 : appendMooseObjectTask ("add_ic", ScalarInitialCondition);
232 273844 : registerMooseObjectTask("add_fv_ic", FVInitialCondition, false);
233 273844 : registerMooseObjectTask("add_ics_physics", InitialCondition, false);
234 273844 : appendMooseObjectTask ("add_ics_physics", FVInitialCondition);
235 273844 : appendMooseObjectTask ("add_ics_physics", ScalarInitialCondition);
236 :
237 273844 : registerMooseObjectTask("add_damper", Damper, false);
238 273844 : registerMooseObjectTask("setup_predictor", Predictor, false);
239 273844 : registerMooseObjectTask("add_time_steppers", TimeStepper, false);
240 273844 : registerMooseObjectTask("add_time_stepper", TimeStepper, false);
241 136922 : registerTask ("compose_time_stepper", true);
242 273844 : registerMooseObjectTask("setup_time_integrators", TimeIntegrator, false);
243 273844 : registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
244 273844 : registerMooseObjectTask("add_convergence", Convergence, false);
245 :
246 273844 : registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
247 273844 : registerMooseObjectTask("add_field_split", Split, false);
248 :
249 273844 : registerMooseObjectTask("add_mesh_division", MeshDivision, false);
250 273844 : registerMooseObjectTask("add_user_object", UserObject, false);
251 273844 : appendMooseObjectTask ("add_user_object", Postprocessor);
252 :
253 273844 : appendDeprecatedMooseObjectTask("add_user_object", Corrector);
254 273844 : registerMooseObjectTask("add_corrector", Corrector, false);
255 273844 : appendDeprecatedMooseObjectTask("add_user_object", MeshModifier);
256 273844 : registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
257 :
258 273844 : registerMooseObjectTask("add_postprocessor", Postprocessor, false);
259 273844 : registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
260 273844 : registerMooseObjectTask("add_reporter", Reporter, false);
261 :
262 273844 : registerMooseObjectTask("add_positions", Positions, false);
263 273844 : registerMooseObjectTask("add_times", Times, false);
264 :
265 273844 : registerMooseObjectTask("add_indicator", Indicator, false);
266 273844 : registerMooseObjectTask("add_marker", Marker, false);
267 :
268 273844 : registerMooseObjectTask("add_multi_app", MultiApp, false);
269 273844 : registerMooseObjectTask("add_transfer", Transfer, false);
270 :
271 273844 : registerMooseObjectTask("add_output", Output, false);
272 :
273 273844 : registerMooseObjectTask("add_control", Control, false);
274 273844 : registerMooseObjectTask("add_chain_control", ChainControl, false);
275 273844 : registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
276 :
277 : // clang-format on
278 :
279 136922 : registerTask("dynamic_object_registration", false);
280 136922 : registerTask("common_output", true);
281 136922 : registerTask("setup_recover_file_base", true);
282 136922 : registerTask("recover_meta_data", true);
283 :
284 136922 : registerTask("add_bounds_vectors", false);
285 136922 : registerTask("add_periodic_bc", false);
286 136922 : registerTask("add_aux_variable", false);
287 136922 : registerTask("add_external_aux_variables", true);
288 136922 : registerTask("add_variable", false);
289 136922 : registerTask("add_mortar_variable", false);
290 :
291 136922 : registerTask("execute_mesh_generators", true);
292 136922 : registerTask("uniform_refine_mesh", false);
293 136922 : registerTask("prepare_mesh", false);
294 136922 : registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
295 136922 : registerTask("setup_mesh_complete", true); // calls prepare
296 136922 : registerTask("post_mesh_prepared", false);
297 136922 : registerTask("add_geometric_rm", false);
298 136922 : registerTask("attach_geometric_rm", true);
299 136922 : registerTask("attach_geometric_rm_final", true);
300 :
301 136922 : registerTask("init_displaced_problem", false);
302 :
303 136922 : registerTask("add_algebraic_rm", false);
304 136922 : registerTask("attach_algebraic_rm", true);
305 136922 : registerTask("add_coupling_rm", false);
306 136922 : registerTask("attach_coupling_rm", true);
307 136922 : registerTask("init_problem", true);
308 136922 : registerTask("check_copy_nodal_vars", true);
309 136922 : registerTask("copy_nodal_vars", true);
310 136922 : registerTask("copy_nodal_aux_vars", true);
311 136922 : registerTask("copy_vars_physics", false);
312 136922 : registerTask("setup_postprocessor_data", false);
313 136922 : registerTask("setup_time_steppers", true);
314 :
315 136922 : registerTask("setup_dampers", true);
316 136922 : registerTask("check_integrity", true);
317 136922 : registerTask("resolve_optional_materials", true);
318 136922 : registerTask("check_integrity_early", true);
319 136922 : registerTask("check_integrity_early_physics", false);
320 136922 : registerTask("setup_quadrature", true);
321 136922 : registerTask("create_tagged_matrices", true);
322 :
323 136922 : registerTask("mesh_modifiers", false);
324 :
325 : /// Additional Actions
326 136922 : registerTask("no_action", false); // Used for Empty Action placeholders
327 136922 : registerTask("set_global_params", false);
328 136922 : registerTask("setup_adaptivity", false);
329 136922 : registerTask("meta_action", false);
330 136922 : registerTask("setup_residual_debug", false);
331 136922 : registerTask("setup_oversampling", false);
332 136922 : registerTask("deprecated_block", false);
333 136922 : registerTask("set_adaptivity_options", false);
334 136922 : registerTask("add_mortar_interface", false);
335 136922 : registerTask("coupling_functor_check", true);
336 136922 : registerTask("add_master_action_material", false);
337 136922 : registerTask("setup_projected_properties", false);
338 136922 : registerTask("create_application_block", false);
339 :
340 : // Dummy Actions (useful for sync points in the dependencies)
341 136922 : registerTask("setup_function_complete", false);
342 136922 : registerTask("setup_variable_complete", false);
343 136922 : registerTask("setup_executioner_complete", false);
344 136922 : registerTask("ready_to_init", true);
345 :
346 : // Output related actions
347 136922 : registerTask("add_output_aux_variables", true);
348 136922 : registerTask("check_output", true);
349 136922 : registerTask("declare_late_reporters", true);
350 :
351 136922 : registerTask("create_problem_default", true);
352 136922 : registerTask("create_problem_custom", false);
353 136922 : registerTask("create_problem_complete", false);
354 :
355 136922 : registerTask("add_default_nonlinear_convergence", true);
356 136922 : registerTask("add_default_multiapp_fixed_point_convergence", true);
357 136922 : registerTask("add_default_steady_state_convergence", true);
358 :
359 136922 : registerTask("chain_control_setup", true);
360 136922 : registerTask("start_webservercontrol", true);
361 :
362 : // Action for setting up the signal-based checkpoint
363 136922 : 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 136922 : 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 102926 : registerTask("add_mfem_problem_operator", true);
495 205852 : addTaskDependency("add_mfem_problem_operator", "init_mesh");
496 205852 : addTaskDependency("add_variable", "add_mfem_problem_operator");
497 205852 : addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
498 205852 : addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
499 205852 : addTaskDependency("add_bc", "add_mfem_problem_operator");
500 205852 : addTaskDependency("add_kernel", "add_mfem_problem_operator");
501 :
502 : // add SubMeshes
503 205852 : registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
504 205852 : addTaskDependency("add_mfem_submeshes", "create_problem_complete");
505 :
506 : // add SubMesh transfers
507 205852 : appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
508 :
509 : // add FESpaces
510 205852 : registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
511 205852 : appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
512 205852 : addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
513 :
514 : // add FESpace hierarchies (must come after fespaces so the base fespace is available)
515 205852 : registerMooseObjectTask("add_mfem_fespace_hierarchies", MFEMFESpaceHierarchy, false);
516 205852 : 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 205852 : addTaskDependency("add_variable", "add_mfem_fespace_hierarchies");
521 205852 : addTaskDependency("add_aux_variable", "add_mfem_fespace_hierarchies");
522 205852 : addTaskDependency("add_elemental_field_variable", "add_mfem_fespace_hierarchies");
523 : // kernels only need fespaces, not hierarchies
524 205852 : addTaskDependency("add_kernel", "add_mfem_fespaces");
525 :
526 : // add QuadratureFunctions
527 205852 : registerMooseObjectTask("add_mfem_quadrature_functions", MFEMQuadratureFunction, false);
528 : // after the last task declaring coefficients the quadrature functions may project
529 205852 : addTaskDependency("add_mfem_quadrature_functions", "add_functor_material");
530 : // before the tasks constructing objects that may consume the declared coefficients
531 205852 : addTaskDependency("add_kernel", "add_mfem_quadrature_functions");
532 205852 : addTaskDependency("add_bc", "add_mfem_quadrature_functions");
533 205852 : addTaskDependency("add_aux_kernel", "add_mfem_quadrature_functions");
534 :
535 : // add complex kernels
536 205852 : registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
537 205852 : registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
538 205852 : addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
539 205852 : addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
540 205852 : addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
541 205852 : addTaskDependency("add_mfem_complex_bc_components", "add_bc");
542 :
543 : // set mesh FE space
544 102926 : registerTask("set_mesh_fe_space", true);
545 205852 : addTaskDependency("set_mesh_fe_space", "add_variable");
546 205852 : addTaskDependency("set_mesh_fe_space", "init_mesh");
547 :
548 : // add solver objects.
549 205852 : registerMooseObjectTask("add_mfem_solver", Moose::MFEM::SolverBase, true);
550 205852 : addTaskDependency("add_mfem_solver", "add_mfem_fespace_hierarchies");
551 205852 : addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
552 205852 : addTaskDependency("add_mfem_solver", "add_variable");
553 102926 : registerTask("resolve_mfem_solvers", true);
554 205852 : addTaskDependency("resolve_mfem_solvers", "add_mfem_solver");
555 205852 : 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 273844 : addTaskDependency("add_interpolation_method_physics", "add_interpolation_method");
561 273844 : addTaskDependency("add_fv_kernel", "add_interpolation_method_physics");
562 273844 : addTaskDependency("add_linear_fv_kernel", "add_interpolation_method_physics");
563 273844 : addTaskDependency("add_fv_kernel", "add_interpolation_method");
564 273844 : addTaskDependency("add_linear_fv_kernel", "add_interpolation_method");
565 :
566 136922 : registerTask("parse_neml2", /*required=*/false);
567 273844 : addTaskDependency("add_material", "parse_neml2");
568 205383 : addTaskDependency("add_user_object", "parse_neml2");
569 68461 : }
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 68461 : registerActions(Syntax & syntax,
608 : ActionFactory & action_factory,
609 : const std::set<std::string> & obj_labels)
610 : {
611 68461 : Registry::registerActionsTo(action_factory, obj_labels);
612 :
613 : // Add these actions here so they are always executed last, without setting any dependency
614 136922 : registerTask("dump_objects", false);
615 68461 : registerTask("finish_input_file_output", false);
616 68461 : }
617 :
618 : void
619 68461 : 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 547688 : registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
627 547688 : registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
628 :
629 547688 : registerSyntax("AddActionComponentAction", "ActionComponents/*");
630 547688 : registerSyntax("CombineComponentsMeshes", "ActionComponents");
631 :
632 547688 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
633 547688 : registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
634 547688 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
635 547688 : registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
636 :
637 547688 : registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
638 547688 : registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
639 547688 : registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
640 :
641 547688 : registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
642 :
643 547688 : registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
644 :
645 547688 : registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
646 547688 : registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
647 :
648 547688 : registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
649 :
650 547688 : registerSyntax("CreateProblemAction", "Problem");
651 547688 : registerSyntax("DynamicObjectRegistrationAction", "Problem");
652 :
653 547688 : registerSyntax("SetupMeshAction", "Mesh");
654 547688 : registerSyntax("SetupMeshCompleteAction", "Mesh");
655 : // Components should be able create a Mesh without a Mesh block
656 547688 : registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
657 547688 : registerSyntax("CreateDisplacedProblemAction", "Mesh");
658 547688 : registerSyntax("DisplayGhostingAction", "Mesh");
659 547688 : registerSyntax("AddMeshGeneratorAction", "Mesh/*");
660 547688 : registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
661 547688 : registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
662 547688 : registerSyntax("ElementIDOutputAction", "Mesh");
663 273844 : syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
664 :
665 547688 : registerSyntax("AddFunctionAction", "Functions/*");
666 273844 : syntax.registerSyntaxType("Functions/*", "FunctionName");
667 :
668 547688 : registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
669 273844 : syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
670 547688 : registerSyntax("AddConvergenceAction", "Convergence/*");
671 273844 : syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
672 :
673 547688 : registerSyntax("GlobalParamsAction", "GlobalParams");
674 :
675 547688 : registerSyntax("AddDistributionAction", "Distributions/*");
676 273844 : syntax.registerSyntaxType("Distributions/*", "DistributionName");
677 :
678 547688 : registerSyntax("AddSamplerAction", "Samplers/*");
679 273844 : syntax.registerSyntaxType("Samplers/*", "SamplerName");
680 :
681 547688 : registerSyntax("SetupDebugAction", "Debug");
682 547688 : registerSyntax("SetupResidualDebugAction", "Debug");
683 :
684 : /// Variable/AuxVariable Actions
685 547688 : registerSyntax("AddVariableAction", "Variables/*");
686 273844 : syntax.registerSyntaxType("Variables/*", "VariableName");
687 273844 : syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
688 :
689 547688 : registerSyntax("AddICAction", "Variables/*/InitialCondition");
690 547688 : registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
691 :
692 547688 : registerSyntax("AddAuxVariableAction", "AuxVariables/*");
693 273844 : syntax.registerSyntaxType("AuxVariables/*", "VariableName");
694 273844 : syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
695 :
696 547688 : registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
697 547688 : registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
698 :
699 547688 : registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
700 547688 : registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
701 :
702 547688 : registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
703 547688 : registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
704 :
705 547688 : registerSyntax("AddMaterialAction", "Materials/*");
706 273844 : syntax.registerSyntaxType("Materials/*", "MaterialName");
707 :
708 547688 : registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
709 273844 : syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
710 :
711 547688 : registerSyntax("AddPostprocessorAction", "Postprocessors/*");
712 273844 : syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
713 273844 : syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
714 :
715 547688 : registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
716 273844 : syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
717 :
718 547688 : registerSyntax("AddReporterAction", "Reporters/*");
719 273844 : syntax.registerSyntaxType("Reporters/*", "ReporterName");
720 :
721 547688 : registerSyntax("AddPositionsAction", "Positions/*");
722 273844 : syntax.registerSyntaxType("Positions/*", "PositionsName");
723 :
724 547688 : registerSyntax("AddTimesAction", "Times/*");
725 273844 : syntax.registerSyntaxType("Times/*", "TimesName");
726 :
727 547688 : registerSyntax("AddDamperAction", "Dampers/*");
728 :
729 547688 : registerSyntax("AddOutputAction", "Outputs/*");
730 547688 : registerSyntax("CommonOutputAction", "Outputs");
731 547688 : registerSyntax("MaterialOutputAction", "Outputs");
732 547688 : registerSyntax("AutoCheckpointAction", "Outputs");
733 273844 : syntax.registerSyntaxType("Outputs/*", "OutputName");
734 :
735 : // Note: Preconditioner Actions will be built by this setup action
736 547688 : registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
737 547688 : registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
738 :
739 547688 : registerSyntax("CreateExecutionerAction", "Executioner");
740 547688 : registerSyntax("ReadExecutorParamsAction", "Executors/*");
741 :
742 547688 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
743 547688 : registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
744 547688 : registerSyntaxTask(
745 : "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
746 547688 : registerSyntaxTask(
747 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
748 547688 : registerSyntaxTask(
749 : "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
750 273844 : syntax.registerSyntaxType("Executors/*", "ExecutorName");
751 :
752 547688 : registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
753 547688 : registerSyntax("SetupPredictorAction", "Executioner/Predictor");
754 : #ifdef LIBMESH_ENABLE_AMR
755 547688 : registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
756 : #endif
757 :
758 547688 : registerSyntax("PartitionerAction", "Mesh/Partitioner");
759 :
760 547688 : registerSyntax("AddDiracKernelAction", "DiracKernels/*");
761 :
762 547688 : registerSyntax("AddDGKernelAction", "DGKernels/*");
763 547688 : registerSyntax("AddFVKernelAction", "FVKernels/*");
764 547688 : registerSyntax("AddFVBCAction", "FVBCs/*");
765 547688 : registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
766 547688 : registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
767 547688 : registerSyntax("CheckFVBCAction", "FVBCs");
768 :
769 547688 : registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
770 :
771 547688 : registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
772 :
773 547688 : registerSyntax("AddConstraintAction", "Constraints/*");
774 :
775 547688 : registerSyntax("AddControlAction", "Controls/*");
776 547688 : registerSyntax("AddChainControlAction", "ChainControls/*");
777 547688 : registerSyntax("AddBoundAction", "Bounds/*");
778 547688 : registerSyntax("AddBoundsVectorsAction", "Bounds");
779 :
780 : // UserObject and some derived classes
781 547688 : registerSyntax("AddUserObjectAction", "UserObjects/*");
782 273844 : syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
783 :
784 547688 : registerSyntax("AddCorrectorAction", "Correctors/*");
785 273844 : syntax.registerSyntaxType("Correctors/*", "UserObjectName");
786 :
787 547688 : registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
788 273844 : syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
789 :
790 547688 : registerSyntax("AddNodalNormalsAction", "NodalNormals");
791 :
792 : // FVInterpolationMethods
793 547688 : registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
794 273844 : syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
795 :
796 : // Indicator
797 547688 : registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
798 547688 : registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
799 273844 : syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
800 :
801 : // Marker
802 547688 : registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
803 547688 : registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
804 273844 : syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
805 :
806 : // New Adaptivity System
807 547688 : registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
808 :
809 : // Deprecated Block
810 547688 : registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
811 :
812 : // Multi Apps
813 547688 : registerSyntax("AddMultiAppAction", "MultiApps/*");
814 273844 : syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
815 :
816 : // Transfers
817 547688 : registerSyntax("AddTransferAction", "Transfers/*");
818 :
819 : // Material derivative test
820 547688 : registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
821 547688 : registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
822 :
823 547688 : registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
824 :
825 : // Application Block System
826 547688 : registerSyntax("CreateApplicationBlockAction", "Application");
827 :
828 : #ifdef MOOSE_MFEM_ENABLED
829 411704 : registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
830 411704 : registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
831 411704 : registerSyntaxTask(
832 : "AddMFEMQuadratureFunctionAction", "QuadratureFunctions/*", "add_mfem_quadrature_functions");
833 411704 : registerSyntaxTask(
834 : "AddMFEMFESpaceHierarchyAction", "FESpaceHierarchies/*", "add_mfem_fespace_hierarchies");
835 411704 : registerSyntaxTask(
836 : "AddMFEMComplexKernelComponentAction", "Kernels/*/*", "add_mfem_complex_kernel_components");
837 411704 : registerSyntaxTask(
838 : "AddMFEMComplexBCComponentAction", "BCs/*/*", "add_mfem_complex_bc_components");
839 411704 : registerSyntaxTask("AddMFEMSolverAction", "Solvers/*", "add_mfem_solver");
840 205852 : syntax.registerSyntaxType("Solvers/*", "MFEMSolverName");
841 : #endif
842 :
843 547688 : registerSyntax("NEML2ActionCommon", "NEML2");
844 479227 : registerSyntax("NEML2Action", "NEML2/*");
845 :
846 68461 : addActionTypes(syntax);
847 68461 : }
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 1207264 : swapLibMeshComm(MPI_Comm new_comm)
865 : {
866 1207264 : MPI_Comm old_comm = PETSC_COMM_WORLD;
867 1207264 : PETSC_COMM_WORLD = new_comm;
868 1207264 : return old_comm;
869 : }
870 :
871 : static bool _color_console = isatty(fileno(stdout));
872 :
873 : bool
874 9925989 : colorConsole()
875 : {
876 9925989 : return _color_console;
877 : }
878 :
879 : bool
880 55825 : setColorConsole(bool use_color, bool force)
881 : {
882 55825 : _color_console = (isatty(fileno(stdout)) || force) && use_color;
883 55825 : return _color_console;
884 : }
885 :
886 2784768 : ScopedThrowOnError::ScopedThrowOnError(const bool throw_on_error)
887 2784768 : : _throw_on_error_before(Moose::_throw_on_error)
888 : {
889 : mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
890 2784768 : Moose::_throw_on_error = throw_on_error;
891 2784768 : }
892 :
893 2784768 : ScopedThrowOnError::ScopedThrowOnError() : ScopedThrowOnError(true) {}
894 :
895 2784768 : 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 16604 : hitMessagePrefix(const hit::Node & node)
913 : {
914 : // Strip meaningless line and column number for CLI args
915 16604 : if (node.filename() == "CLI_ARGS")
916 1274 : return "CLI_ARGS:\n";
917 : // If using the root node, don't add line info
918 15967 : if (node.isRoot())
919 3 : return node.filename() + ":\n";
920 15964 : 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
|
