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