www.mooseframework.org
Moose.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
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 #include "libmesh/petsc_vector.h"
13 #include "libmesh/petsc_matrix.h"
14 #include <petscsnes.h>
15 
16 #include "Moose.h"
17 #include "MooseApp.h"
18 
19 #include "ActionWarehouse.h"
20 #include "ActionFactory.h"
21 #include "AuxiliarySystem.h"
22 #include "Factory.h"
23 #include "PetscSupport.h"
24 #include "Syntax.h"
25 #include "MooseSyntax.h"
26 
27 #include <unistd.h>
28 
29 // Define the available execute flags for MOOSE. The flags using a hex value are setup to retain the
30 // same numbers that were utilized with older versions of MOOSE for keeping existing applications
31 // working using the deprecated flags. In the future, as in the EXEC_SAME_AS_MULTIAPP flag, there is
32 // no reason to keep these flags bitwise comparable or to assigned an id because the MultiMooseEnum
33 // that is used to store these has convenience methods for determining the what flags are active.
34 const ExecFlagType EXEC_NONE("NONE", 0x00); // 0
35 const ExecFlagType EXEC_INITIAL("INITIAL", 0x01); // 1
36 const ExecFlagType EXEC_LINEAR("LINEAR", 0x02); // 2
37 const ExecFlagType EXEC_NONLINEAR("NONLINEAR", 0x04); // 4
38 const ExecFlagType EXEC_TIMESTEP_END("TIMESTEP_END", 0x08); // 8
39 const ExecFlagType EXEC_TIMESTEP_BEGIN("TIMESTEP_BEGIN", 0x10); // 16
40 const ExecFlagType EXEC_FINAL("FINAL", 0x20); // 32
41 const ExecFlagType EXEC_FORCED("FORCED", 0x40); // 64
42 const ExecFlagType EXEC_FAILED("FAILED", 0x80); // 128
43 const ExecFlagType EXEC_CUSTOM("CUSTOM", 0x100); // 256
44 const ExecFlagType EXEC_SUBDOMAIN("SUBDOMAIN", 0x200); // 512
45 const ExecFlagType EXEC_PRE_DISPLACE("PRE_DISPLACE");
46 const ExecFlagType EXEC_SAME_AS_MULTIAPP("SAME_AS_MULTIAPP");
47 const ExecFlagType EXEC_PRE_MULTIAPP_SETUP("PRE_MULTIAPP_SETUP");
48 const ExecFlagType EXEC_TRANSFER("TRANSFER");
49 
50 void
51 MooseVecView(NumericVector<Number> & vector)
52 {
53  PetscVector<Number> & petsc_vec = static_cast<PetscVector<Number> &>(vector);
54  VecView(petsc_vec.vec(), 0);
55 }
56 
57 void
58 MooseMatView(SparseMatrix<Number> & mat)
59 {
60  PetscMatrix<Number> & petsc_mat = static_cast<PetscMatrix<Number> &>(mat);
61  MatView(petsc_mat.mat(), 0);
62 }
63 
64 namespace Moose
65 {
66 
67 void associateSyntaxInner(Syntax & syntax, ActionFactory & action_factory);
68 
69 void
71 {
72  registerObjects(f, {"MooseApp"});
73  associateSyntaxInner(s, af);
74  registerActions(s, af, {"MooseApp"});
76 }
77 
78 void
80 {
81  mooseDeprecated("use registerAll instead of registerObjects");
82  registerObjects(factory, {"MooseApp"});
83 }
84 
85 void
86 registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
87 {
88  Registry::registerObjectsTo(factory, obj_labels);
89 }
90 
91 void
93 {
106  // clang-format off
107  /**************************/
108  /**** Register Actions ****/
109  /**************************/
110  registerMooseObjectTask("create_problem", Problem, false);
111  registerMooseObjectTask("setup_executioner", Executioner, false);
112 
113  // This task does not construct an object, but it needs all of the parameters that
114  // would normally be used to construct an object.
115  registerMooseObjectTask("determine_system_type", Executioner, true);
116 
117  registerMooseObjectTask("setup_mesh", MooseMesh, false);
118  registerMooseObjectTask("set_mesh_base", MooseMesh, false);
119  registerMooseObjectTask("init_mesh", MooseMesh, false);
120  registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
121  registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
122 
123  registerMooseObjectTask("add_kernel", Kernel, false);
124  appendMooseObjectTask ("add_kernel", EigenKernel);
125  appendMooseObjectTask ("add_kernel", VectorKernel);
126 
127  registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
128 
129  registerMooseObjectTask("add_material", Material, false);
130  registerMooseObjectTask("add_bc", BoundaryCondition, false);
131 
132  registerMooseObjectTask("add_function", Function, false);
133  registerMooseObjectTask("add_distribution", Distribution, false);
134  registerMooseObjectTask("add_sampler", Sampler, false);
135 
136  registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
137  appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
138  registerMooseObjectTask("add_elemental_field_variable", AuxKernel, false);
139 
140  registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
141  registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
142  registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
143  registerMooseObjectTask("add_dg_kernel", DGKernel, false);
144  registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
145  registerMooseObjectTask("add_constraint", Constraint, false);
146 
147  registerMooseObjectTask("add_ic", InitialCondition, false);
148  appendMooseObjectTask ("add_ic", ScalarInitialCondition);
149 
150  registerMooseObjectTask("add_damper", Damper, false);
151  registerMooseObjectTask("setup_predictor", Predictor, false);
152  registerMooseObjectTask("setup_time_stepper", TimeStepper, false);
153  registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
154 
155  registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
156  registerMooseObjectTask("add_field_split", Split, false);
157 
158  registerMooseObjectTask("add_user_object", UserObject, false);
159  appendMooseObjectTask ("add_user_object", Postprocessor);
160 
161  registerMooseObjectTask("add_postprocessor", Postprocessor, false);
162  registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
163 
164  registerMooseObjectTask("add_indicator", Indicator, false);
165  registerMooseObjectTask("add_marker", Marker, false);
166 
167  registerMooseObjectTask("add_multi_app", MultiApp, false);
168  registerMooseObjectTask("add_transfer", Transfer, false);
169 
170  registerMooseObjectTask("add_output", Output, false);
171 
172  registerMooseObjectTask("add_control", Control, false);
173  registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
174 
175  // clang-format on
176 
177  registerTask("dynamic_object_registration", false);
178  registerTask("common_output", true);
179  registerTask("setup_recover_file_base", true);
180 
181  registerTask("add_bounds_vectors", false);
182  registerTask("add_periodic_bc", false);
183  registerTask("add_aux_variable", false);
184  registerTask("add_external_aux_variables", true);
185  registerTask("add_variable", false);
186 
187  registerTask("execute_mesh_modifiers", false);
188  registerTask("execute_mesh_generators", true);
189  registerTask("uniform_refine_mesh", false);
190  registerTask("prepare_mesh", false);
191  registerTask("delete_remote_elements_post_equation_systems_init", false);
192  registerTask("setup_mesh_complete", true); // calls prepare
193  registerTask("add_geometric_rm", false);
194  registerTask("attach_geometric_rm", true);
195 
196  registerTask("init_displaced_problem", false);
197 
198  registerTask("add_algebraic_rm", false);
199  registerTask("attach_algebraic_rm", true);
200  registerTask("init_problem", true);
201  registerTask("check_copy_nodal_vars", true);
202  registerTask("copy_nodal_vars", true);
203  registerTask("copy_nodal_aux_vars", true);
204  registerTask("setup_postprocessor_data", false);
205 
206  registerTask("setup_dampers", true);
207  registerTask("check_integrity", true);
208  registerTask("check_integrity_early", true);
209  registerTask("setup_quadrature", true);
210 
212  registerTask("no_action", false); // Used for Empty Action placeholders
213  registerTask("set_global_params", false);
214  registerTask("setup_adaptivity", false);
215  registerTask("meta_action", false);
216  registerTask("setup_residual_debug", false);
217  registerTask("setup_oversampling", false);
218  registerTask("deprecated_block", false);
219  registerTask("set_adaptivity_options", false);
220  registerTask("add_mortar_interface", false);
221 
222  // Dummy Actions (useful for sync points in the dependencies)
223  registerTask("setup_function_complete", false);
224  registerTask("setup_variable_complete", false);
225  registerTask("ready_to_init", true);
226  appendMooseObjectTask("ready_to_init", InterfaceKernel);
227  appendMooseObjectTask("ready_to_init", DGKernel);
228 
229  // Output related actions
230  registerTask("add_output_aux_variables", true);
231  registerTask("check_output", true);
232 
233  registerTask("create_problem_default", true);
234  registerTask("create_problem_custom", false);
235  registerTask("create_problem_complete", false);
236 
237  /**************************/
238  /****** Dependencies ******/
239  /**************************/
249  syntax.addDependencySets("(meta_action)"
250  "(dynamic_object_registration)"
251  "(common_output)"
252  "(set_global_params)"
253  "(setup_recover_file_base)"
254  "(setup_mesh)"
255  "(add_mesh_generator)"
256  "(execute_mesh_generators)"
257  "(set_mesh_base)"
258  "(check_copy_nodal_vars)"
259  "(add_partitioner)"
260  "(add_geometric_rm)"
261  "(attach_geometric_rm)"
262  "(init_mesh)"
263  "(prepare_mesh)"
264  "(add_mesh_modifier)"
265  "(execute_mesh_modifiers)"
266  "(add_mortar_interface)"
267  "(uniform_refine_mesh)"
268  "(setup_mesh_complete)"
269  "(determine_system_type)"
270  "(create_problem)"
271  "(create_problem_custom)"
272  "(create_problem_default)"
273  "(create_problem_complete)"
274  "(setup_postprocessor_data)"
275  "(setup_time_integrator)"
276  "(setup_executioner)"
277  "(check_integrity_early)"
278  "(setup_predictor)"
279  "(init_displaced_problem)"
280  "(add_aux_variable, add_variable, add_elemental_field_variable,"
281  " add_external_aux_variables)"
282  "(setup_variable_complete)"
283  "(setup_quadrature)"
284  "(add_function)"
285  "(add_distribution)"
286  "(add_sampler)"
287  "(add_periodic_bc)"
288  "(add_user_object)"
289  "(setup_function_complete)"
290  "(setup_adaptivity)"
291  "(set_adaptivity_options)"
292  "(add_ic)"
293  "(add_constraint, add_field_split)"
294  "(add_preconditioning)"
295  "(setup_time_stepper)"
296  "(ready_to_init)"
297  "(setup_dampers)"
298  "(setup_residual_debug)"
299  "(add_bounds_vectors)"
300  "(add_multi_app)"
301  "(add_transfer)"
302  "(copy_nodal_vars, copy_nodal_aux_vars)"
303  "(add_material)"
304  "(add_output_aux_variables)"
305  "(add_algebraic_rm)"
306  "(attach_algebraic_rm)"
307  "(init_problem)"
308  "(delete_remote_elements_post_equation_systems_init)"
309  "(add_output)"
310  "(add_postprocessor)"
311  "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
312  // to be after material objects are created.
313  "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
314  " add_nodal_kernel, add_dg_kernel, add_interface_kernel,"
315  " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker)"
316  "(add_control)"
317  "(check_output)"
318  "(check_integrity)");
319 }
320 
349 void
350 registerActions(Syntax & syntax, ActionFactory & action_factory)
351 {
352  mooseDeprecated("use registerAll instead of registerActions");
353  registerActions(syntax, action_factory, {"MooseApp"});
354 }
355 
356 void
358  ActionFactory & action_factory,
359  const std::set<std::string> & obj_labels)
360 {
361  Registry::registerActionsTo(action_factory, obj_labels);
362 
363  // TODO: Why is this here?
364  registerTask("finish_input_file_output", false);
365 }
366 
367 void
369 {
370  registerExecFlag(EXEC_NONE);
371  registerExecFlag(EXEC_INITIAL);
372  registerExecFlag(EXEC_LINEAR);
373  registerExecFlag(EXEC_NONLINEAR);
374  registerExecFlag(EXEC_TIMESTEP_END);
375  registerExecFlag(EXEC_TIMESTEP_BEGIN);
376  registerExecFlag(EXEC_FINAL);
377  registerExecFlag(EXEC_FORCED);
378  registerExecFlag(EXEC_FAILED);
379  registerExecFlag(EXEC_CUSTOM);
380  registerExecFlag(EXEC_TRANSFER);
381  registerExecFlag(EXEC_SUBDOMAIN);
382  registerExecFlag(EXEC_PRE_DISPLACE);
383  registerExecFlag(EXEC_SAME_AS_MULTIAPP);
384  registerExecFlag(EXEC_PRE_MULTIAPP_SETUP);
385 }
386 
387 void
388 associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
389 {
395  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
396  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
397  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
398  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
399 
400  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
401  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
402  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
403  registerSyntaxTask("AddKernelAction", "Bounds/*", "add_aux_kernel");
404 
405  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
406  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
407 
408  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
409 
410  registerSyntax("CreateProblemAction", "Problem");
411  registerSyntax("DynamicObjectRegistrationAction", "Problem");
412 
413  registerSyntax("SetupMeshAction", "Mesh");
414  registerSyntax("SetupMeshCompleteAction", "Mesh");
415  registerSyntax("CreateDisplacedProblemAction", "Mesh");
416  registerSyntax("DisplayGhostingAction", "Mesh");
417 
418  registerSyntax("AddMeshModifierAction", "MeshModifiers/*");
419  registerSyntax("AddMeshGeneratorAction", "MeshGenerators/*");
420 
421  registerSyntax("AddFunctionAction", "Functions/*");
422  syntax.registerSyntaxType("Functions/*", "FunctionName");
423 
424  registerSyntax("GlobalParamsAction", "GlobalParams");
425 
426  registerSyntax("AddDistributionAction", "Distributions/*");
427  registerSyntax("AddSamplerAction", "Samplers/*");
428 
429  registerSyntax("SetupDebugAction", "Debug");
430  registerSyntax("SetupResidualDebugAction", "Debug");
431 
433  registerSyntax("AddVariableAction", "Variables/*");
434  syntax.registerSyntaxType("Variables/*", "VariableName");
435  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
436 
437  registerSyntax("AddICAction", "Variables/*/InitialCondition");
438 
439  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
440  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
441  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
442 
443  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
444 
445  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
446  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
447 
448  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
449 
450  registerSyntax("AddMaterialAction", "Materials/*");
451 
452  registerSyntax("SetupPostprocessorDataAction", "Postprocessors/*");
453  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
454  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
455  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
456 
457  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
458  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
459 
460  registerSyntax("AddDamperAction", "Dampers/*");
461 
462  registerSyntax("AddOutputAction", "Outputs/*");
463  registerSyntax("CommonOutputAction", "Outputs");
464  syntax.registerSyntaxType("Outputs/*", "OutputName");
465 
466  // Note: Preconditioner Actions will be built by this setup action
467  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
468  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
469 
470  registerSyntax("CreateExecutionerAction", "Executioner");
471  registerSyntax("SetupTimeStepperAction", "Executioner/TimeStepper");
472  registerSyntax("SetupTimeIntegratorAction", "Executioner/TimeIntegrator");
473 
474  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
475  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
476 #ifdef LIBMESH_ENABLE_AMR
477  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
478 #endif
479 
480  registerSyntax("PartitionerAction", "Mesh/Partitioner");
481 
482  registerSyntax("AddDiracKernelAction", "DiracKernels/*");
483 
484  registerSyntax("AddDGKernelAction", "DGKernels/*");
485 
486  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
487 
488  registerSyntax("AddConstraintAction", "Constraints/*");
489 
490  registerSyntax("AddUserObjectAction", "UserObjects/*");
491  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
492  registerSyntax("AddControlAction", "Controls/*");
493  registerSyntax("AddBoundsVectorsAction", "Bounds");
494 
495  registerSyntax("AddNodalNormalsAction", "NodalNormals");
496 
497  // Indicator
498  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
499  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
500  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
501 
502  // Marker
503  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
504  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
505  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
506 
507  // New Adaptivity System
508  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
509 
510  // Deprecated Block
511  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
512 
513  // Multi Apps
514  registerSyntax("AddMultiAppAction", "MultiApps/*");
515  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
516 
517  // Transfers
518  registerSyntax("AddTransferAction", "Transfers/*");
519 
520  // Material derivative test
521  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
522  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
523 
524  addActionTypes(syntax);
525 }
526 
527 void
528 associateSyntax(Syntax & syntax, ActionFactory & action_factory)
529 {
530  associateSyntaxInner(syntax, action_factory);
531  registerActions(syntax, action_factory);
532 }
533 
534 void
536 {
537 #ifdef LIBMESH_HAVE_PETSC
538  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
540 #endif // LIBMESH_HAVE_PETSC
541 }
542 
543 MPI_Comm
544 swapLibMeshComm(MPI_Comm new_comm)
545 {
546 #ifdef LIBMESH_HAVE_PETSC
547  MPI_Comm old_comm = PETSC_COMM_WORLD;
548  PETSC_COMM_WORLD = new_comm;
549  return old_comm;
550 #endif // LIBMESH_HAVE_PETSC
551 }
552 
553 static bool _color_console = isatty(fileno(stdout));
554 
555 bool
557 {
558  return _color_console;
559 }
560 
561 bool
562 setColorConsole(bool use_color, bool force)
563 {
564  _color_console = (isatty(fileno(stdout)) || force) && use_color;
565  return _color_console;
566 }
567 
568 bool _warnings_are_errors = false;
569 
570 bool _deprecated_is_error = false;
571 
572 bool _throw_on_error = false;
573 
574 } // namespace Moose
Base class for function objects.
Definition: Function.h:40
bool colorConsole()
Returns whether Console coloring is turned on (default: true).
Definition: Moose.C:556
Base class for split-based preconditioners.
Definition: Split.h:29
MPI_Comm swapLibMeshComm(MPI_Comm new_comm)
Swap the libMesh MPI communicator out for ours.
Definition: Moose.C:544
const ExecFlagType EXEC_CUSTOM("CUSTOM", 0x100)
const ExecFlagType EXEC_LINEAR("LINEAR", 0x02)
Generic factory class for build all sorts of objects.
Definition: Factory.h:153
void setSolverDefaults(FEProblemBase &problem)
Definition: Moose.C:535
This is the base class for Samplers.
Definition: Sampler.h:40
Base class for predictors.
Definition: Predictor.h:33
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
Definition: PetscSupport.C:601
bool _warnings_are_errors
Variable to toggle any warning into an error (includes deprecated code warnings)
Definition: Moose.C:568
const ExecFlagType EXEC_SUBDOMAIN("SUBDOMAIN", 0x200)
const ExecFlagType EXEC_NONE("NONE", 0x00)
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:350
const ExecFlagType EXEC_TIMESTEP_END("TIMESTEP_END", 0x08)
This is a template class that implements the workhorse compute and computeNodal methods.
Base class for all Constraint types.
Definition: Constraint.h:39
Class that hold the whole problem being solved.
Definition: Problem.h:24
Definition: Marker.h:39
MeshModifiers are objects that can modify or add to an existing mesh.
Definition: MeshModifier.h:25
Base class for time stepping.
Definition: TimeStepper.h:26
void associateSyntax(Syntax &syntax, ActionFactory &action_factory)
Definition: Moose.C:528
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:52
All Distributions should inherit from this class.
Definition: Distribution.h:22
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
void registerObjects(Factory &factory)
Definition: Moose.C:79
void MooseMatView(SparseMatrix< Number > &mat)
Definition: Moose.C:58
Base class for MOOSE preconditioners.
Based class for output objects.
Definition: Output.h:41
const ExecFlagType EXEC_PRE_MULTIAPP_SETUP("PRE_MULTIAPP_SETUP")
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:120
void registerExecFlags(Factory &factory)
Definition: Moose.C:368
The DGKernel class is responsible for calculating the residuals for various physics on internal sides...
Definition: DGKernel.h:23
bool _deprecated_is_error
Variable to toggle only deprecated warnings as errors.
Definition: Moose.C:570
static bool _color_console
Definition: Moose.C:553
Base class for making kernels that work on auxiliary scalar variables.
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:64
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
const ExecFlagType EXEC_INITIAL("INITIAL", 0x01)
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:32
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:236
Base class for all Postprocessors.
Definition: Postprocessor.h:29
The behavior of this kernel is controlled by one problem-wise global parameter eigen_on_current - boo...
Definition: EigenKernel.h:28
const ExecFlagType EXEC_FINAL("FINAL", 0x20)
InterfaceKernel is responsible for interfacing physics across subdomains.
InitialConditions are objects that set the initial value of variables.
const ExecFlagType EXEC_TIMESTEP_BEGIN("TIMESTEP_BEGIN", 0x10)
void addDependencySets(const std::string &action_sets)
Adds all dependencies in a single call.
Definition: Syntax.C:64
const ExecFlagType EXEC_FORCED("FORCED", 0x40)
Materials compute MaterialProperties.
Definition: Material.h:46
const ExecFlagType EXEC_PRE_DISPLACE("PRE_DISPLACE")
const ExecFlagType EXEC_NONLINEAR("NONLINEAR", 0x04)
Base class for creating new types of boundary conditions.
Base class for time integrators.
const ExecFlagType EXEC_SAME_AS_MULTIAPP("SAME_AS_MULTIAPP")
Class for containing MooseEnum item information.
Definition: MooseEnumItem.h:21
Base class for Control objects.
Definition: Control.h:37
void registerSyntaxType(const std::string &syntax, const std::string &type)
Register a type with a block.
Definition: Syntax.C:298
const ExecFlagType EXEC_TRANSFER("TRANSFER")
void registerAll(Factory &f, ActionFactory &af, Syntax &s)
Register objects that are in MOOSE.
Definition: Moose.C:70
Base class for MOOSE partitioner.
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
Definition: Moose.C:562
Base class for deriving dampers.
Definition: Damper.h:29
Holding syntax for parsing input files.
Definition: Syntax.h:20
Definition: Kernel.h:20
Base class for creating new auxiliary kernels and auxiliary boundary conditions.
Definition: AuxKernel.h:33
Definition: Moose.h:112
Base class for creating new types of boundary conditions.
Definition: NodalKernel.h:48
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:57
Base class for Postprocessors that produce a vector of values.
const ExecFlagType EXEC_FAILED("FAILED", 0x80)
bool _throw_on_error
Variable to turn on exceptions during mooseError() and mooseWarning(), should only be used with MOOSE...
Definition: Moose.C:572
MeshGenerators are objects that can modify or add to an existing mesh.
Definition: MeshGenerator.h:30
A DiracKernel is used when you need to add contributions to the residual by means of multiplying some...
Definition: DiracKernel.h:45
Base class for user-specific data.
Definition: UserObject.h:37
void addActionTypes(Syntax &syntax)
Definition: Moose.C:92
void associateSyntaxInner(Syntax &syntax, ActionFactory &action_factory)
Definition: Moose.C:388
Base class for all Transfer objects.
Definition: Transfer.h:40
void MooseVecView(NumericVector< Number > &vector)
Definition: Moose.C:51