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