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