https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Moose.C
Go to the documentation of this file.
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#include "FVGradientMethod.h"
25
26#include "hit/parse.h"
27
28#include <unistd.h>
29
30const ExecFlagType EXEC_NONE = registerDefaultExecFlag("NONE");
31const ExecFlagType EXEC_INITIAL = registerDefaultExecFlag("INITIAL");
32const ExecFlagType EXEC_LINEAR = registerDefaultExecFlag("LINEAR");
33const ExecFlagType EXEC_LINEAR_CONVERGENCE = registerDefaultExecFlag("LINEAR_CONVERGENCE");
34const ExecFlagType EXEC_NONLINEAR = registerDefaultExecFlag("NONLINEAR");
35const ExecFlagType EXEC_NONLINEAR_CONVERGENCE = registerDefaultExecFlag("NONLINEAR_CONVERGENCE");
36const ExecFlagType EXEC_POSTCHECK = registerDefaultExecFlag("POSTCHECK");
37const ExecFlagType EXEC_TIMESTEP_END = registerDefaultExecFlag("TIMESTEP_END");
38const ExecFlagType EXEC_TIMESTEP_BEGIN = registerDefaultExecFlag("TIMESTEP_BEGIN");
40 registerExecFlag("MULTIAPP_FIXED_POINT_ITERATION_END");
42 registerDefaultExecFlag("MULTIAPP_FIXED_POINT_END");
44 registerDefaultExecFlag("MULTIAPP_FIXED_POINT_BEGIN");
46 registerDefaultExecFlag("MULTIAPP_FIXED_POINT_CONVERGENCE");
48 registerDefaultExecFlag("MULTISYSTEM_FIXED_POINT_ITERATION_END");
49const ExecFlagType EXEC_FINAL = registerDefaultExecFlag("FINAL");
50const ExecFlagType EXEC_FORCED = registerExecFlag("FORCED");
51const ExecFlagType EXEC_FAILED = registerExecFlag("FAILED");
52const ExecFlagType EXEC_CUSTOM = registerDefaultExecFlag("CUSTOM");
53const ExecFlagType EXEC_SUBDOMAIN = registerExecFlag("SUBDOMAIN");
54const ExecFlagType EXEC_ALWAYS = registerExecFlag("ALWAYS");
55const ExecFlagType EXEC_PRE_DISPLACE = registerExecFlag("PRE_DISPLACE");
56const ExecFlagType EXEC_SAME_AS_MULTIAPP = registerExecFlag("SAME_AS_MULTIAPP");
57const ExecFlagType EXEC_PRE_MULTIAPP_SETUP = registerExecFlag("PRE_MULTIAPP_SETUP");
58const ExecFlagType EXEC_TRANSFER = registerExecFlag("TRANSFER");
59const ExecFlagType EXEC_PRE_KERNELS = registerExecFlag("PRE_KERNELS");
60#ifdef LIBMESH_ENABLE_AMR
61const ExecFlagType EXEC_POST_ADAPTIVITY = registerExecFlag("POST_ADAPTIVITY");
62#endif
63
64namespace Moose
65{
66
67bool
69{
70 return exec_flag == EXEC_LINEAR || exec_flag == EXEC_NONLINEAR || exec_flag == EXEC_POSTCHECK;
71}
72
73void associateSyntaxInner(Syntax & syntax, ActionFactory & action_factory);
74
75void
77{
78 registerObjects(f, {"MooseApp"});
80 registerActions(s, af, {"MooseApp"});
81 registerAppDataFilePath("moose");
82 registerRepository("moose", "github.com/idaholab/moose");
83
84 // Citation emitted by the --citations command-line option: the current framework paper is tied to
85 // "MooseApp" (so it is cited whenever a MooseApp object is used, and apps composed of MooseApp
86 // inherit it), and modules register their own app citations (via Registry::addAppCitation) which
87 // are cited only when one of their objects is actually used. PETSc and its sub-packages register
88 // their own citations, which --citations emits through PETSc.
89 Registry::addAppCitation("MooseApp",
90 "harbour2025moose",
91 R"(@article{harbour2025moose,
92 title = {4.0 {MOOSE}: Enabling massively parallel Multiphysics simulation},
93 journal = {{SoftwareX}},
94 volume = {31},
95 pages = {102264},
96 year = {2025},
97 issn = {2352-7110},
98 doi = {https://doi.org/10.1016/j.softx.2025.102264},
99 url = {https://www.sciencedirect.com/science/article/pii/S2352711025002316},
100 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},
101})");
102
103 // The libMesh citation is registered under "libMesh" but not tied to any object label, so the
104 // per-object loop in MooseApp::requestCitations() does not emit it; emission is gated on the
105 // finite element backend actually used in the run.
106 Registry::addAppCitation("libMesh",
107 "libMeshPaper",
108 R"(@article{libMeshPaper,
109 author = {B.~S.~Kirk and J.~W.~Peterson and R.~H.~Stogner and G.~F.~Carey},
110 title = {{\texttt{libMesh}: A C++ Library for Parallel Adaptive Mesh
111 Refinement/Coarsening Simulations}},
112 journal = {Engineering with Computers},
113 volume = {22},
114 number = {3--4},
115 pages = {237--254},
116 year = {2006},
117 url={http://dx.doi.org/10.1007/s00366-006-0049-3}
118})");
119
120#ifdef MOOSE_MFEM_ENABLED
121 // Like libMesh, the MFEM citation is emitted by MooseApp::requestCitations() only when the run
122 // actually uses the MFEM backend.
124 "mfem-2024",
125 R"(@article{mfem-2024,
126 title = {High-Performance Finite Elements with {MFEM}},
127 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},
128 journal = {The International Journal of High Performance Computing Applications},
129 volume = {38},
130 number = {5},
131 pages = {447--467},
132 year = {2024},
133 publisher = {SAGE Publications Sage UK: London, England},
134})");
135#endif
136}
137
138void
139registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
140{
141 Registry::registerObjectsTo(factory, obj_labels);
142}
143
144void
145addActionTypes(Syntax & syntax)
146{
159 // clang-format off
160 /**************************/
161 /**** Register Actions ****/
162 /**************************/
163 registerMooseObjectTask("create_problem", Problem, false);
164 registerMooseObjectTask("setup_executioner", Executioner, false);
165 registerMooseObjectTask("read_executor", Executor, false);
166 registerTask("add_executor", true);
167
168 // TODO Organize these somewhere
169 registerTask("init_physics", false);
170 registerTask("init_component_physics", false);
171 registerTask("meta_action_component", false);
172 registerTask("setup_component", false);
173 // 'list_component' is used to retrieve ActionComponents for the syntax JSON
174 registerTask("list_component", false);
175
176 // This task does not construct an object, but it needs all of the parameters that
177 // would normally be used to construct an object.
178 registerMooseObjectTask("determine_system_type", Executioner, true);
179
180 registerMooseObjectTask("setup_mesh", MooseMesh, false);
181 registerMooseObjectTask("set_mesh_base", MooseMesh, false);
182 registerMooseObjectTask("init_mesh", MooseMesh, false);
183 registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
184 registerTask("create_added_mesh_generators", true);
185 registerMooseObjectTask("append_mesh_generator", MeshGenerator, false);
186
187 registerMooseObjectTask("add_kernel", Kernel, false);
188 appendMooseObjectTask ("add_kernel", EigenKernel);
189 appendMooseObjectTask ("add_kernel", VectorKernel);
190 appendMooseObjectTask ("add_kernel", ArrayKernel);
191 appendMooseObjectTask ("add_kernel", ADArrayKernel);
192
193 registerMooseObjectTask("add_variable", MooseVariableBase, false);
194 registerMooseObjectTask("add_aux_variable", MooseVariableBase, false);
195 registerMooseObjectTask("add_elemental_field_variable", MooseVariableBase, false);
196 registerMooseObjectTask("add_variables_physics", MooseVariableBase, false);
197
198 registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
199
200 registerMooseObjectTask("add_functor_material", FunctorMaterial, false);
201 registerMooseObjectTask("add_material", MaterialBase, false);
202 appendDeprecatedMooseObjectTask("add_material", FunctorMaterial);
203 registerMooseObjectTask("add_materials_physics", FunctorMaterial, false);
204 appendMooseObjectTask ("add_materials_physics", MaterialBase);
205
206 registerMooseObjectTask("add_bc", BoundaryCondition, false);
207
208 registerMooseObjectTask("add_function", Function, false);
209
210 registerMooseObjectTask("add_distribution", Distribution, false);
211 registerMooseObjectTask("add_sampler", Sampler, false);
212
213 registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
214 appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
215 appendMooseObjectTask ("add_aux_kernel", ArrayAuxKernel);
216
217 registerMooseObjectTask("add_bound", Bounds, false);
218
219 registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
220 registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
221 registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
222 appendMooseObjectTask ("add_dirac_kernel", VectorDiracKernel);
223 registerMooseObjectTask("add_dg_kernel", DGKernel, false);
224 registerMooseObjectTask("add_fv_kernel", FVKernel, false);
225 registerMooseObjectTask("add_gradient_method", FVGradientMethod, false);
226 registerMooseObjectTask("add_interpolation_method", FVInterpolationMethod, false);
227 registerMooseObjectTask("add_interpolation_method_physics", FVInterpolationMethod, false);
228 registerMooseObjectTask("add_linear_fv_kernel", LinearFVKernel, false);
229 registerMooseObjectTask("add_fv_bc", FVBoundaryCondition, false);
230 registerMooseObjectTask("add_linear_fv_bc", LinearFVBoundaryCondition, false);
231 registerMooseObjectTask("add_fv_ik", FVInterfaceKernel, false);
232 registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
233 appendMooseObjectTask ("add_interface_kernel", VectorInterfaceKernel);
234 registerMooseObjectTask("add_constraint", Constraint, false);
235 registerMooseObjectTask("add_hybridized_kernel", HDGKernel, false);
236 registerMooseObjectTask("add_hybridized_integrated_bc", HDGIntegratedBC, false);
237
238 registerMooseObjectTask("add_ic", InitialCondition, false);
239 appendMooseObjectTask ("add_ic", ScalarInitialCondition);
240 registerMooseObjectTask("add_fv_ic", FVInitialCondition, false);
241 registerMooseObjectTask("add_ics_physics", InitialCondition, false);
242 appendMooseObjectTask ("add_ics_physics", FVInitialCondition);
243 appendMooseObjectTask ("add_ics_physics", ScalarInitialCondition);
244
245 registerMooseObjectTask("add_damper", Damper, false);
246 registerMooseObjectTask("setup_predictor", Predictor, false);
247 registerMooseObjectTask("add_time_steppers", TimeStepper, false);
248 registerMooseObjectTask("add_time_stepper", TimeStepper, false);
249 registerTask ("compose_time_stepper", true);
250 registerMooseObjectTask("setup_time_integrators", TimeIntegrator, false);
251 registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
252 registerMooseObjectTask("add_convergence", Convergence, false);
253
254 registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
255 registerMooseObjectTask("add_field_split", Split, false);
256
257 registerMooseObjectTask("add_mesh_division", MeshDivision, false);
258 registerMooseObjectTask("add_user_object", UserObject, false);
259 appendMooseObjectTask ("add_user_object", Postprocessor);
260
261 appendDeprecatedMooseObjectTask("add_user_object", Corrector);
262 registerMooseObjectTask("add_corrector", Corrector, false);
263 appendDeprecatedMooseObjectTask("add_user_object", MeshModifier);
264 registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
265
266 registerMooseObjectTask("add_postprocessor", Postprocessor, false);
267 registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
268 registerMooseObjectTask("add_reporter", Reporter, false);
269
270 registerMooseObjectTask("add_positions", Positions, false);
271 registerMooseObjectTask("add_times", Times, false);
272
273 registerMooseObjectTask("add_indicator", Indicator, false);
274 registerMooseObjectTask("add_marker", Marker, false);
275
276 registerMooseObjectTask("add_multi_app", MultiApp, false);
277 registerMooseObjectTask("add_transfer", Transfer, false);
278
279 registerMooseObjectTask("add_output", Output, false);
280
281 registerMooseObjectTask("add_control", Control, false);
282 registerMooseObjectTask("add_chain_control", ChainControl, false);
283 registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
284
285 // clang-format on
286
287 registerTask("dynamic_object_registration", false);
288 registerTask("common_output", true);
289 registerTask("setup_recover_file_base", true);
290 registerTask("recover_meta_data", true);
291
292 registerTask("add_bounds_vectors", false);
293 registerTask("add_periodic_bc", false);
294 registerTask("add_aux_variable", false);
295 registerTask("add_external_aux_variables", true);
296 registerTask("add_variable", false);
297 registerTask("add_mortar_variable", false);
298
299 registerTask("execute_mesh_generators", true);
300 registerTask("uniform_refine_mesh", false);
301 registerTask("prepare_mesh", false);
302 registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
303 registerTask("setup_mesh_complete", true); // calls prepare
304 registerTask("post_mesh_prepared", false);
305 registerTask("add_geometric_rm", false);
306 registerTask("attach_geometric_rm", true);
307 registerTask("attach_geometric_rm_final", true);
308
309 registerTask("init_displaced_problem", false);
310
311 registerTask("add_algebraic_rm", false);
312 registerTask("attach_algebraic_rm", true);
313 registerTask("add_coupling_rm", false);
314 registerTask("attach_coupling_rm", true);
315 registerTask("init_problem", true);
316 registerTask("check_copy_nodal_vars", true);
317 registerTask("copy_nodal_vars", true);
318 registerTask("copy_nodal_aux_vars", true);
319 registerTask("copy_vars_physics", false);
320 registerTask("setup_postprocessor_data", false);
321 registerTask("setup_time_steppers", true);
322
323 registerTask("setup_dampers", true);
324 registerTask("check_integrity", true);
325 registerTask("resolve_optional_materials", true);
326 registerTask("check_integrity_early", true);
327 registerTask("check_integrity_early_physics", false);
328 registerTask("flush_shared_physics_variables", false);
329 registerTask("setup_quadrature", true);
330 registerTask("create_tagged_matrices", true);
331
332 registerTask("mesh_modifiers", false);
333
335 registerTask("no_action", false); // Used for Empty Action placeholders
336 registerTask("set_global_params", false);
337 registerTask("setup_adaptivity", false);
338 registerTask("meta_action", false);
339 registerTask("setup_residual_debug", false);
340 registerTask("setup_oversampling", false);
341 registerTask("deprecated_block", false);
342 registerTask("set_adaptivity_options", false);
343 registerTask("add_mortar_interface", false);
344 registerTask("coupling_functor_check", true);
345 registerTask("add_master_action_material", false);
346 registerTask("setup_projected_properties", false);
347 registerTask("create_application_block", false);
348
349 // Dummy Actions (useful for sync points in the dependencies)
350 registerTask("setup_function_complete", false);
351 registerTask("setup_variable_complete", false);
352 registerTask("setup_executioner_complete", false);
353 registerTask("ready_to_init", true);
354
355 // Output related actions
356 registerTask("add_output_aux_variables", true);
357 registerTask("check_output", true);
358 registerTask("declare_late_reporters", true);
359
360 registerTask("create_problem_default", true);
361 registerTask("create_problem_custom", false);
362 registerTask("create_problem_complete", false);
363
364 registerTask("add_default_nonlinear_convergence", true);
365 registerTask("add_default_multiapp_fixed_point_convergence", true);
366 registerTask("add_default_steady_state_convergence", true);
367
368 registerTask("chain_control_setup", true);
369 registerTask("start_webservercontrol", true);
370
371 // Action for setting up the signal-based checkpoint
372 registerTask("auto_checkpoint_action", true);
373 /**************************/
374 /****** Dependencies ******/
375 /**************************/
386 // clang-format off
387 syntax.addDependencySets("(meta_action)"
388 "(meta_action_component)"
389 "(dynamic_object_registration)"
390 "(common_output)"
391 "(set_global_params)"
392 "(setup_recover_file_base)"
393 "(check_copy_nodal_vars)"
394 "(setup_mesh)"
395 "(add_geometric_rm)"
396 "(add_partitioner)"
397 "(add_mesh_generator)"
398 "(create_added_mesh_generators)"
399 "(append_mesh_generator)"
400 "(execute_mesh_generators)"
401 "(recover_meta_data)"
402 "(set_mesh_base)"
403 "(attach_geometric_rm)"
404 "(init_mesh)"
405 "(prepare_mesh)"
406 "(add_mortar_interface)"
407 "(uniform_refine_mesh)"
408 "(setup_mesh_complete)"
409 "(post_mesh_prepared)"
410 "(determine_system_type)"
411 "(create_problem)"
412 "(create_problem_custom)"
413 "(create_problem_default)"
414 "(create_problem_complete)"
415 "(init_displaced_problem)" // Problem must be init-ed before we start adding functors
416 "(add_function)" // Functions can depend on scalar variables & PPs, but this dependence can be
417 // added on initialSetup() rather than construction
418 "(init_component_physics)" // components must add their blocks to physics before init_physics
419 "(init_physics)"
420 "(setup_postprocessor_data)"
421 "(setup_time_integrator, setup_time_integrators)"
422 "(setup_executioner)"
423 "(setup_executioner_complete)"
424 "(setup_component)" // no particular reason for that placement
425 "(read_executor)"
426 "(add_executor)"
427 "(check_integrity_early)"
428 "(setup_predictor)"
429 "(add_aux_variable, add_variable, add_elemental_field_variable,"
430 " add_external_aux_variables)"
431 "(add_variables_physics)" // physics can skip adding variables if they already exist
432 "(flush_shared_physics_variables)" // adds the variables that Physics requested to share
433 "(add_mortar_variable)"
434 "(setup_variable_complete)"
435 "(check_integrity_early_physics)" // checks that systems and variables are consistent
436 "(setup_quadrature)"
437 "(add_convergence)"
438 "(add_default_nonlinear_convergence,"
439 " add_default_multiapp_fixed_point_convergence,"
440 " add_default_steady_state_convergence)"
441 "(add_positions)"
442 "(add_periodic_bc)"
443 "(add_gradient_method)"
444 "(add_user_object, add_corrector, add_mesh_modifier)"
445 "(add_field_split)" // split objects required before field split preconditioner itself
446 "(add_preconditioning)" // preconditioner may introduce objects such as static condensation which influence the underlying types of tagged matrices
447 "(create_tagged_matrices)"
448 "(add_distribution)"
449 "(add_sampler)"
450 "(setup_function_complete)"
451 "(setup_adaptivity)"
452 "(set_adaptivity_options)"
453 "(add_ic, add_fv_ic)"
454 "(add_ics_physics)" // physics can skip adding initial conditions if they already exist
455 "(add_constraint)"
456 "(add_times)"
457 "(add_time_stepper, add_time_steppers)"
458 "(compose_time_stepper)"
459 "(setup_time_steppers)"
460 "(ready_to_init)"
461 "(setup_dampers)"
462 "(setup_residual_debug)"
463 "(add_bounds_vectors)"
464 "(add_mesh_division)" // NearestPositionsDivision uses a Positions
465 "(add_multi_app)"
466 "(add_transfer)"
467 "(copy_nodal_vars, copy_nodal_aux_vars, copy_vars_physics)"
468 "(add_material)"
469 "(add_master_action_material)"
470 "(add_functor_material)"
471 "(add_materials_physics)"
472 "(setup_projected_properties)"
473 "(add_output_aux_variables)"
474 "(add_output)"
475 "(auto_checkpoint_action)"
476 "(add_postprocessor)"
477 "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
478 // to be after material objects are created.
479 "(add_reporter)"
480 "(declare_late_reporters)"
481 "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
482 " add_nodal_kernel, add_dg_kernel, add_fv_kernel, add_interpolation_method,"
483 " add_interpolation_method_physics, add_linear_fv_kernel,"
484 " add_fv_bc, add_linear_fv_bc, add_fv_ik, add_interface_kernel,"
485 " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker,"
486 " add_bound, add_hybridized_kernel, add_hybridized_integrated_bc)"
487 "(resolve_optional_materials)"
488 "(add_algebraic_rm)"
489 "(add_coupling_rm)"
490 "(attach_geometric_rm_final)"
491 "(attach_algebraic_rm)"
492 "(attach_coupling_rm)"
493 "(coupling_functor_check)"
494 "(delete_remote_elements_after_late_geometric_ghosting)"
495 "(init_problem)"
496 "(add_control, add_chain_control)"
497 "(chain_control_setup)"
498 "(start_webservercontrol)"
499 "(check_output)"
500 "(check_integrity)"
501 "(create_application_block)");
502 // clang-format on
503
504#ifdef MOOSE_MFEM_ENABLED
505 // add SubMeshes
506 registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
507 addTaskDependency("add_mfem_submeshes", "create_problem_complete");
508
509 // add SubMesh transfers
510 appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
511
512 // add FESpaces
513 registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
514 appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
515 addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
516
517 // add FESpace hierarchies (must come after fespaces so the base fespace is available)
518 registerMooseObjectTask("add_mfem_fespace_hierarchies", MFEMFESpaceHierarchy, false);
519 addTaskDependency("add_mfem_fespace_hierarchies", "add_mfem_fespaces");
520
521 // variables must wait for hierarchies since a variable may reference a hierarchy's
522 // finest level via fespace_hierarchy = ...
523 addTaskDependency("add_variable", "add_mfem_fespace_hierarchies");
524 addTaskDependency("add_aux_variable", "add_mfem_fespace_hierarchies");
525 addTaskDependency("add_elemental_field_variable", "add_mfem_fespace_hierarchies");
526 // kernels only need fespaces, not hierarchies
527 addTaskDependency("add_kernel", "add_mfem_fespaces");
528
529 // add complex kernels
530 registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
531 registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
532 addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
533 addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
534 addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
535 addTaskDependency("add_mfem_complex_bc_components", "add_bc");
536
537 // set mesh FE space
538 registerTask("set_mesh_fe_space", true);
539 addTaskDependency("set_mesh_fe_space", "add_variable");
540 addTaskDependency("set_mesh_fe_space", "init_mesh");
541
542 // add user-specified weak forms to build equation systems used in this problem
543 registerMooseObjectTask("add_mfem_weak_forms", MFEMWeakFormBase, false);
544 addTaskDependency("add_mfem_weak_forms", "init_mesh");
545 addTaskDependency("add_mfem_weak_forms", "add_variable");
546 addTaskDependency("add_mfem_weak_forms", "add_aux_variable");
547 addTaskDependency("add_mfem_weak_forms", "add_elemental_field_variable");
548 addTaskDependency("add_mfem_weak_forms", "add_kernel");
549 addTaskDependency("add_mfem_weak_forms", "add_bc");
550 addTaskDependency("add_mfem_weak_forms", "add_mfem_complex_kernel_components");
551 addTaskDependency("add_mfem_weak_forms", "add_mfem_complex_bc_components");
552 addTaskDependency("add_mfem_weak_forms", "add_mfem_fespace_hierarchies");
553
554 // build MFEM EquationSystems from MFEMWeakForms used in this problem
555 registerTask("set_mfem_equation_systems", true);
556 addTaskDependency("set_mfem_equation_systems", "add_mfem_weak_forms");
557
558 // add solver objects
559 registerMooseObjectTask("add_mfem_solver", Moose::MFEM::SolverBase, true);
560 addTaskDependency("add_mfem_solver", "set_mfem_equation_systems");
561
562 // resolve dependency order between added solver objects
563 registerTask("resolve_mfem_solvers", true);
564 addTaskDependency("resolve_mfem_solvers", "add_mfem_solver");
565
566 // indicators/estimators before markers
567 addTaskDependency("add_marker", "add_indicator");
568
569 // add problem composers
570 registerMooseObjectTask("add_mfem_problem_composer", MFEMProblemComposer, false);
571 addTaskDependency("add_mfem_problem_composer", "set_mfem_equation_systems");
572 addTaskDependency("add_mfem_problem_composer", "resolve_mfem_solvers");
573
574 // build MFEM ProblemOperators from MFEMProblemComposers used in this problem
575 registerTask("set_mfem_problem_operators", true);
576 addTaskDependency("set_mfem_problem_operators", "add_mfem_problem_composer");
577
578 addTaskDependency("init_problem", "set_mfem_problem_operators");
579
580#endif
581
582 // Linear FV kernels fetch FVInterpolationMethod instances in their constructors. Some Physics
583 // add linear FV kernels on the generic FV kernel task.
584 addTaskDependency("add_interpolation_method_physics", "add_interpolation_method");
585 addTaskDependency("add_fv_kernel", "add_interpolation_method_physics");
586 addTaskDependency("add_linear_fv_kernel", "add_interpolation_method_physics");
587 addTaskDependency("add_fv_kernel", "add_interpolation_method");
588 addTaskDependency("add_linear_fv_kernel", "add_interpolation_method");
589 // Linear FV kernels and BCs may register named FVGradientMethod instances in their constructors
590 addTaskDependency("add_user_object", "add_gradient_method");
591 addTaskDependency("add_linear_fv_kernel", "add_gradient_method");
592 addTaskDependency("add_linear_fv_bc", "add_gradient_method");
593
594 registerTask("parse_neml2", /*required=*/false);
595 addTaskDependency("add_material", "parse_neml2");
596 addTaskDependency("add_user_object", "parse_neml2");
597}
598
627void
628registerActions(Syntax & syntax, ActionFactory & action_factory)
629{
630 mooseDeprecated("use registerAll instead of registerActions");
631 registerActions(syntax, action_factory, {"MooseApp"});
632}
633
634void
635registerActions(Syntax & syntax,
636 ActionFactory & action_factory,
637 const std::set<std::string> & obj_labels)
638{
639 Registry::registerActionsTo(action_factory, obj_labels);
640
641 // Add these actions here so they are always executed last, without setting any dependency
642 registerTask("dump_objects", false);
643 registerTask("finish_input_file_output", false);
644}
645
646void
647associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
648{
654 registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
655 registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
656
657 registerSyntax("AddActionComponentAction", "ActionComponents/*");
658 registerSyntax("CombineComponentsMeshes", "ActionComponents");
659
660 registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
661 registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
662 registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
663 registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
664
665 registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
666 registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
667 registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
668
669 registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
670
671 registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
672
673 registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
674 registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
675
676 registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
677
678 registerSyntax("CreateProblemAction", "Problem");
679 registerSyntax("DynamicObjectRegistrationAction", "Problem");
680
681 registerSyntax("SetupMeshAction", "Mesh");
682 registerSyntax("SetupMeshCompleteAction", "Mesh");
683 // Components should be able create a Mesh without a Mesh block
684 registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
685 registerSyntax("CreateDisplacedProblemAction", "Mesh");
686 registerSyntax("DisplayGhostingAction", "Mesh");
687 registerSyntax("AddMeshGeneratorAction", "Mesh/*");
688 registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
689 registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
690 registerSyntax("ElementIDOutputAction", "Mesh");
691 syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
692
693 registerSyntax("AddFunctionAction", "Functions/*");
694 syntax.registerSyntaxType("Functions/*", "FunctionName");
695
696 registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
697 syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
698 registerSyntax("AddConvergenceAction", "Convergence/*");
699 syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
700
701 registerSyntax("GlobalParamsAction", "GlobalParams");
702
703 registerSyntax("AddDistributionAction", "Distributions/*");
704 syntax.registerSyntaxType("Distributions/*", "DistributionName");
705
706 registerSyntax("AddSamplerAction", "Samplers/*");
707 syntax.registerSyntaxType("Samplers/*", "SamplerName");
708
709 registerSyntax("SetupDebugAction", "Debug");
710 registerSyntax("SetupResidualDebugAction", "Debug");
711
713 registerSyntax("AddVariableAction", "Variables/*");
714 syntax.registerSyntaxType("Variables/*", "VariableName");
715 syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
716
717 registerSyntax("AddICAction", "Variables/*/InitialCondition");
718 registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
719
720 registerSyntax("AddAuxVariableAction", "AuxVariables/*");
721 syntax.registerSyntaxType("AuxVariables/*", "VariableName");
722 syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
723
724 registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
725 registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
726
727 registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
728 registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
729
730 registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
731 registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
732
733 registerSyntax("AddMaterialAction", "Materials/*");
734 syntax.registerSyntaxType("Materials/*", "MaterialName");
735
736 registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
737 syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
738
739 registerSyntax("AddPostprocessorAction", "Postprocessors/*");
740 syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
741 syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
742
743 registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
744 syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
745
746 registerSyntax("AddReporterAction", "Reporters/*");
747 syntax.registerSyntaxType("Reporters/*", "ReporterName");
748
749 registerSyntax("AddPositionsAction", "Positions/*");
750 syntax.registerSyntaxType("Positions/*", "PositionsName");
751
752 registerSyntax("AddTimesAction", "Times/*");
753 syntax.registerSyntaxType("Times/*", "TimesName");
754
755 registerSyntax("AddDamperAction", "Dampers/*");
756
757 registerSyntax("AddOutputAction", "Outputs/*");
758 registerSyntax("CommonOutputAction", "Outputs");
759 registerSyntax("MaterialOutputAction", "Outputs");
760 registerSyntax("AutoCheckpointAction", "Outputs");
761 syntax.registerSyntaxType("Outputs/*", "OutputName");
762
763 // Note: Preconditioner Actions will be built by this setup action
764 registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
765 registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
766
767 registerSyntax("CreateExecutionerAction", "Executioner");
768 registerSyntax("ReadExecutorParamsAction", "Executors/*");
769
770 registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
771 registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
772 registerSyntaxTask(
773 "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
774 registerSyntaxTask(
775 "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
776 registerSyntaxTask(
777 "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
778 syntax.registerSyntaxType("Executors/*", "ExecutorName");
779
780 registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
781 registerSyntax("SetupPredictorAction", "Executioner/Predictor");
782#ifdef LIBMESH_ENABLE_AMR
783 registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
784#endif
785
786 registerSyntax("PartitionerAction", "Mesh/Partitioner");
787
788 registerSyntax("AddDiracKernelAction", "DiracKernels/*");
789
790 registerSyntax("AddDGKernelAction", "DGKernels/*");
791 registerSyntax("AddFVKernelAction", "FVKernels/*");
792 registerSyntax("AddFVBCAction", "FVBCs/*");
793 registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
794 registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
795 registerSyntax("CheckFVBCAction", "FVBCs");
796
797 registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
798
799 registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
800
801 registerSyntax("AddConstraintAction", "Constraints/*");
802
803 registerSyntax("AddControlAction", "Controls/*");
804 registerSyntax("AddChainControlAction", "ChainControls/*");
805 registerSyntax("AddBoundAction", "Bounds/*");
806 registerSyntax("AddBoundsVectorsAction", "Bounds");
807
808 // UserObject and some derived classes
809 registerSyntax("AddUserObjectAction", "UserObjects/*");
810 syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
811
812 registerSyntax("AddCorrectorAction", "Correctors/*");
813 syntax.registerSyntaxType("Correctors/*", "UserObjectName");
814
815 registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
816 syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
817
818 registerSyntax("AddNodalNormalsAction", "NodalNormals");
819
820 // FVInterpolationMethods
821 registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
822 syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
823
824 // FVGradientMethods
825 registerSyntax("AddFVGradientMethodAction", "FVGradientMethods/*");
826 syntax.registerSyntaxType("FVGradientMethods/*", "GradientMethodName");
827
828 // Indicator
829 registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
830 registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
831 syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
832
833 // Marker
834 registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
835 registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
836 syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
837
838 // New Adaptivity System
839 registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
840
841 // Deprecated Block
842 registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
843
844 // Multi Apps
845 registerSyntax("AddMultiAppAction", "MultiApps/*");
846 syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
847
848 // Transfers
849 registerSyntax("AddTransferAction", "Transfers/*");
850
851 registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");
852
853 // Application Block System
854 registerSyntax("CreateApplicationBlockAction", "Application");
855
856#ifdef MOOSE_MFEM_ENABLED
857 registerSyntaxTask("AddMFEMWeakFormAction", "WeakForms/*", "add_mfem_weak_forms");
858 syntax.registerSyntaxType("WeakForms/*", "MFEMWeakFormName");
859 syntax.registerSyntaxType("Kernels/*", "MFEMKernelName");
860 syntax.registerSyntaxType("BCs/*", "MFEMBoundaryConditionName");
861 registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
862 registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
863 registerSyntaxTask(
864 "AddMFEMFESpaceHierarchyAction", "FESpaceHierarchies/*", "add_mfem_fespace_hierarchies");
865 registerSyntaxTask(
866 "AddMFEMComplexKernelComponentAction", "Kernels/*/*", "add_mfem_complex_kernel_components");
867 registerSyntaxTask(
868 "AddMFEMComplexBCComponentAction", "BCs/*/*", "add_mfem_complex_bc_components");
869 registerSyntaxTask("AddMFEMSolverAction", "Solvers/*", "add_mfem_solver");
870 syntax.registerSyntaxType("Solvers/*", "MFEMSolverName");
871 registerSyntaxTask(
872 "AddMFEMProblemComposerAction", "ProblemComposers/*", "add_mfem_problem_composer");
873#endif
875 registerSyntax("NEML2ActionCommon", "NEML2");
876 registerSyntax("NEML2Action", "NEML2/*");
878 addActionTypes(syntax);
879}
880
881void
882associateSyntax(Syntax & syntax, ActionFactory & action_factory)
884 associateSyntaxInner(syntax, action_factory);
885 registerActions(syntax, action_factory);
886}
887
888void
890{
891 // May be a touch expensive to create a new DM every time, but probably safer to do it this way
893}
894
895MPI_Comm
896swapLibMeshComm(MPI_Comm new_comm)
897{
898 MPI_Comm old_comm = PETSC_COMM_WORLD;
899 PETSC_COMM_WORLD = new_comm;
900 return old_comm;
901}
902
903static bool _color_console = isatty(fileno(stdout));
904
905bool
908 return _color_console;
910
911bool
912setColorConsole(bool use_color, bool force)
913{
914 _color_console = (isatty(fileno(stdout)) || force) && use_color;
916}
917
918ScopedThrowOnError::ScopedThrowOnError(const bool throw_on_error)
919 : _throw_on_error_before(Moose::_throw_on_error)
920{
921 mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
922 Moose::_throw_on_error = throw_on_error;
923}
924
925ScopedThrowOnError::ScopedThrowOnError() : ScopedThrowOnError(true) {}
927ScopedThrowOnError::~ScopedThrowOnError() { Moose::_throw_on_error = _throw_on_error_before; }
929ScopedDeprecatedIsError::ScopedDeprecatedIsError(const bool deprecated_is_error)
930 : _deprecated_is_error_before(Moose::_deprecated_is_error)
932 mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
933 Moose::_deprecated_is_error = deprecated_is_error;
934}
935
936ScopedDeprecatedIsError::ScopedDeprecatedIsError() : ScopedDeprecatedIsError(true) {}
937
938ScopedDeprecatedIsError::~ScopedDeprecatedIsError()
939{
940 Moose::_deprecated_is_error = _deprecated_is_error_before;
941}
942
943std::string
944hitMessagePrefix(const hit::Node & node)
945{
946 // Strip meaningless line and column number for CLI args
947 if (node.filename() == "CLI_ARGS")
948 return "CLI_ARGS:\n";
949 // If using the root node, don't add line info
950 if (node.isRoot())
951 return node.filename() + ":\n";
952 return node.fileLocation() + ":\n";
953}
954
955bool _warnings_are_errors = false;
956bool _deprecated_is_error = false;
957bool _throw_on_error = false;
958bool _throw_on_warning = false;
959volatile std::sig_atomic_t interrupt_signal_number = 0;
960bool show_multiple = false;
961
962} // namespace Moose
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition MooseError.h:363
const ExecFlagType EXEC_FORCED
Definition Moose.C:50
const ExecFlagType EXEC_TRANSFER
Definition Moose.C:58
const ExecFlagType EXEC_PRE_MULTIAPP_SETUP
Definition Moose.C:57
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END
Definition Moose.C:41
const ExecFlagType EXEC_MULTISYSTEM_FIXED_POINT_ITERATION_END
Definition Moose.C:47
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE
Definition Moose.C:45
const ExecFlagType EXEC_SUBDOMAIN
Definition Moose.C:53
const ExecFlagType EXEC_TIMESTEP_END
Definition Moose.C:37
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition Moose.C:38
const ExecFlagType EXEC_SAME_AS_MULTIAPP
Definition Moose.C:56
const ExecFlagType EXEC_POSTCHECK
Definition Moose.C:36
const ExecFlagType EXEC_ALWAYS
Definition Moose.C:54
const ExecFlagType EXEC_CUSTOM
Definition Moose.C:52
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_ITERATION_END
Definition Moose.C:39
const ExecFlagType EXEC_POST_ADAPTIVITY
Definition Moose.C:61
const ExecFlagType EXEC_LINEAR_CONVERGENCE
Definition Moose.C:33
const ExecFlagType EXEC_INITIAL
Definition Moose.C:31
const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN
Definition Moose.C:43
const ExecFlagType EXEC_LINEAR
Definition Moose.C:32
const ExecFlagType EXEC_PRE_KERNELS
Definition Moose.C:59
const ExecFlagType EXEC_NONLINEAR
Definition Moose.C:34
const ExecFlagType EXEC_FAILED
Definition Moose.C:51
const ExecFlagType EXEC_NONE
Definition Moose.C:30
const ExecFlagType EXEC_FINAL
Definition Moose.C:49
const ExecFlagType EXEC_NONLINEAR_CONVERGENCE
Definition Moose.C:35
const ExecFlagType EXEC_PRE_DISPLACE
Definition Moose.C:55
const ExecFlagType EXEC_POSTCHECK
Definition Moose.C:36
const ExecFlagType EXEC_LINEAR
Definition Moose.C:32
const ExecFlagType EXEC_NONLINEAR
Definition Moose.C:34
Base class for array variable (equation) kernels using automatic differentiation.
Specialized factory for generic Action System objects.
Base class for making kernels that work on auxiliary scalar variables.
Base class for creating new types of boundary conditions.
Control that additionally provides the capability to produce/consume data values, to allow control op...
Base class for all Constraint types.
Definition Constraint.h:20
Base class for Control objects.
Definition Control.h:44
Base class for convergence criteria.
Definition Convergence.h:26
The DGKernel class is responsible for calculating the residuals for various physics on internal sides...
Definition DGKernel.h:19
Base class for deriving dampers.
Definition Damper.h:28
A DiracKernel is used when you need to add contributions to the residual by means of multiplying some...
Definition DiracKernel.h:33
All Distributions should inherit from this class.
The behavior of this kernel is controlled by one problem-wise global parameter eigen_on_current - boo...
Definition EigenKernel.h:24
Executioners are objects that do the actual work of solving your problem.
Definition Executioner.h:37
The Executor class directs the execution flow of simulations.
Definition Executor.h:27
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Base class for creating new types of boundary conditions.
Base class for linear finite-volume cell-gradient methods.
This is a template class that implements the workhorse compute and computeNodal methods.
Base class for creating kernels that interface physics between subdomains.
Registered base class for linear FV interpolation objects.
FVKernel is a base class for all finite volume method kernels.
Definition FVKernel.h:36
Generic factory class for build all sorts of objects.
Definition Factory.h:29
Base class for function objects.
Definition Function.h:30
FunctorMaterials compute functor material properties.
Base kernel for hybridized finite element formulations.
Definition HDGKernel.h:18
This is a template class that implements the workhorse compute and computeNodal methods.
InterfaceKernel and VectorInterfaceKernel is responsible for interfacing physics across subdomains.
Base class for boundary conditions for linear FV systems.
Base class for finite volume kernels that contribute to a linear systems.
Builds and owns a mfem::ParFiniteElementSpaceHierarchy from a base FESpace by applying a sequence of ...
Constructs and stores an mfem::ParFiniteElementSpace object.
Definition MFEMFESpace.h:21
Interface required for all MFEMProblemComposers.
Class to transfer MFEM variable data to or from a restricted copy of the variable defined on an a sub...
Base class for construction of a mfem::ParSubMesh object.
Definition MFEMSubMesh.h:21
Base class for MOOSE objects that construct objects derived from Moose::MFEM::EquationSystem.
MaterialBases compute MaterialProperties.
Base class for MeshDivision objects.
MeshGenerators are objects that can modify or add to an existing mesh.
Class for containing MooseEnum item information.
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition MooseMesh.h:95
Base class for MOOSE partitioner.
Base class for MOOSE preconditioners.
Base variable class.
Base class for wrapping mfem::Solver-derived classes.
ScopedThrowOnError()
Default constructor, which sets Moose::_throw_on_error = true.
Definition Moose.C:896
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition MultiApp.h:140
Base class for creating nodal kernels with hand-coded Jacobians.
Definition NodalKernel.h:19
Based class for output objects.
Definition Output.h:52
Positions objects are under the hood Reporters.
Definition Positions.h:21
Base class for all Postprocessors.
Base class for predictors.
Definition Predictor.h:29
Class that hold the whole problem being solved.
Definition Problem.h:20
static void addAppCitation(const std::string &app_name, const std::string &key, const std::string &bibtex)
Register a citation (the full BibTeX bibtex text, identified by key) tied to the app app_name; emitte...
Definition Registry.C:198
static void registerActionsTo(ActionFactory &f, const std::set< std::string > &labels)
This registers all Actions known to the registry that have the given label(s) with the factory f.
Definition Registry.C:69
static void registerObjectsTo(Factory &f, const std::set< std::string > &labels)
This registers all MooseObjects known to the registry that have the given label(s) with the factory f...
Definition Registry.C:35
Reporter objects allow for the declaration of arbitrary data types that are aggregate values for a si...
Definition Reporter.h:48
This is the base class for Samplers as used within the Stochastic Tools module.
Definition Sampler.h:52
InitialConditions are objects that set the initial value of variables.
Base class for split-based preconditioners.
Definition Split.h:26
Holding syntax for parsing input files.
Definition Syntax.h:22
void addDependencySets(const std::string &action_sets)
Adds all dependencies in a single call.
Definition Syntax.C:69
void registerSyntaxType(const std::string &syntax, const std::string &type)
Register a type with a block.
Definition Syntax.C:363
Base class for time integrators.
Base class for time stepping.
Definition TimeStepper.h:23
Times objects are under the hood Reporters, but limited to a vector of Real.
Definition Times.h:19
Base class for all Transfer objects.
Definition Transfer.h:40
Base class for user-specific data.
Definition UserObject.h:20
Base class for Postprocessors that produce a vector of values.
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
void setSolverDefaults(FEProblemBase &problem)
Definition Moose.C:860
bool _deprecated_is_error
Variable to toggle only deprecated warnings as errors.
Definition Moose.C:927
void registerObjects(Factory &factory, const std::set< std::string > &obj_labels)
Definition Moose.C:110
bool _throw_on_error
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or wh...
Definition Moose.C:928
bool isSolverExecFlag(const ExecFlagType &exec_flag)
Definition Moose.C:68
bool show_multiple
Set to false (the default) to display an error message only once for each error call code location (a...
Definition Moose.C:931
void associateSyntax(Syntax &syntax, ActionFactory &action_factory)
Definition Moose.C:853
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
Definition Moose.C:883
void registerActions(Syntax &syntax, ActionFactory &action_factory)
Multiple Action class can be associated with a single input file section, in which case all associate...
Definition Moose.C:599
void registerAll(Factory &f, ActionFactory &af, Syntax &s)
Register objects that are in MOOSE.
Definition Moose.C:76
volatile std::sig_atomic_t interrupt_signal_number
Used by the signal handler to determine if we should write a checkpoint file out at any point during ...
Definition Moose.C:930
bool _throw_on_warning
Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests.
Definition Moose.C:929
bool _warnings_are_errors
Variable to toggle any warning into an error (includes deprecated code warnings)
Definition Moose.C:926
bool colorConsole()
Returns whether Console coloring is turned on (default: true).
Definition Moose.C:877
void addActionTypes(Syntax &syntax)
Definition Moose.C:116
static bool _color_console
Definition Moose.C:874
std::string hitMessagePrefix(const hit::Node &node)
Get the prefix to be associated with a hit node for a message.
Definition Moose.C:915
void associateSyntaxInner(Syntax &syntax, ActionFactory &action_factory)
Definition Moose.C:618
MPI_Comm swapLibMeshComm(MPI_Comm new_comm)
Swap the libMesh MPI communicator out for ours.
Definition Moose.C:867