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