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