FEProblemBase

The FEProblemBase class is an intermediate base class containing all of the common logic for running the various MOOSE simulations. MOOSE has two built-in types of problems FEProblem for solving "normal" physics problems and EigenProblem for solving Eigenvalue problems. Additionally, MOOSE contains an ExternalProblem problem useful for creating "MOOSE-wrapped Apps".

A normal (default) Problem object that contains a single NonlinearSystem and a single AuxiliarySystem object.

Convenience Zeros

One of the advantages of the MOOSE framework is the ease at building up Multiphysics simulations. Coupling is a first-class feature and filling out residuals, or material properties with coupling is very natural. When coupling is optional, it is often handy to have access to valid data structures that may be used in-place of the actual coupled variables. This makes it possible to avoid branch statements inside of your residual statements and other computationally intensive areas of code. One of the ways MOOSE makes this possible is by making several different types of "zero" variables available. The following statements illustrate how optional coupling may be implemented with these zeros.


// In the constructor initialization list of a Kernel

  _velocity_vector(isParamValid("velocity_vector") ? coupledGradient("velocity_vector") : _grad_zero)


// The residual statement

  return _test[_i][_qp] * (_velocity_vector[_qp] * _grad_u[_qp]);

Selective Reinit

The system automatically determines which variables should be made available for use on the current element ("reinit"-ed). Each variable is tracked on calls through the coupling interface. Variables that are not needed are simply not prepared. This can save significant amounts of time on systems that have several active variables.

Finite Element Concepts

Shape Functions

While the weak form is essentially what you need for adding physics to MOOSE, in traditional finite element software more work is necessary.
We need to discretize our weak form and select a set of simple "basis functions" amenable for manipulation by a computer.

Example of linear Lagrange shape function associated with single node on triangular mesh

1D linear Lagrange shape functions

Our discretized expansion of $var element = document.getElementById("moose-equation-957a3dfc-236f-4c10-9be5-535a99e1d819");katex.render("u", element, {displayMode:false,throwOnError:false});$ takes on the following form: $var element = document.getElementById("moose-equation-58c060eb-1b14-42f2-9cb5-369b202d586f");katex.render("u \\approx u_h = \\sum_{j=1}^N u_j \\phi_j", element, {displayMode:false,throwOnError:false});$
The $var element = document.getElementById("moose-equation-e2f7028a-bc9a-4b74-96c7-bab1ac81f396");katex.render("\\phi_j", element, {displayMode:false,throwOnError:false});$ here are called "basis functions"
These $var element = document.getElementById("moose-equation-046fda30-1f16-49f2-a803-c5e5e458c1a6");katex.render("\\phi_j", element, {displayMode:false,throwOnError:false});$ form the basis for the "trial function", $var element = document.getElementById("moose-equation-19d638c7-0175-4aeb-b95c-51cfaef93c82");katex.render("u_h", element, {displayMode:false,throwOnError:false});$
Analogous to the $var element = document.getElementById("moose-equation-0d05cb8a-af42-4f0a-b6fb-e1228e747316");katex.render("x^n", element, {displayMode:false,throwOnError:false});$ we used earlier
The gradient of $var element = document.getElementById("moose-equation-d0031986-3b66-4939-aa7a-505ca10a654b");katex.render("u", element, {displayMode:false,throwOnError:false});$ can be expanded similarly: $var element = document.getElementById("moose-equation-93ad0800-739e-4437-a9bd-d2a76053714f");katex.render("\\nabla u \\approx \\nabla u_h = \\sum_{j=1}^N u_j \\nabla \\phi_j", element, {displayMode:false,throwOnError:false});$
In the Galerkin finite element method, the same basis functions are used for both the trial and test functions: $var element = document.getElementById("moose-equation-0147a8cf-fed3-4799-9953-469377643652");katex.render("\\psi = \\{\\phi_i\\}_{i=1}^N", element, {displayMode:false,throwOnError:false});$
Substituting these expansions back into our weak form, we get: $var element = document.getElementById("moose-equation-5f7b8e9e-dce6-4fa6-a2bf-9bf2d743cbaa");katex.render("\\left(\\nabla\\psi_i, k\\nabla u_h \\right) - \\langle\\psi_i, k\\nabla u_h\\cdot \\hat{n} \\rangle + \\left(\\psi_i, \\vec{\\beta} \\cdot \\nabla u_h\\right) - \\left(\\psi_i, f\\right) = 0, \\quad i=1,\\ldots,N", element, {displayMode:false,throwOnError:false});$
The left-hand side of the equation above is what we generally refer to as the $var element = document.getElementById("moose-equation-1b860981-e838-4ff3-bb25-cdfe5a2229c0");katex.render("i^{th}", element, {displayMode:false,throwOnError:false});$ component of our "Residual Vector" and write as $var element = document.getElementById("moose-equation-c12ddaf3-5c57-4909-b377-fd7c6cb5abf1");katex.render("R_i(u_h)", element, {displayMode:false,throwOnError:false});$ .
Shape Functions are the functions that get multiplied by coefficients and summed to form the solution.
Individual shape functions are restrictions of the global basis functions to individual elements.
They are analogous to the $var element = document.getElementById("moose-equation-7769e480-3fcc-4ad0-a142-166444b2dcec");katex.render("x^n", element, {displayMode:false,throwOnError:false});$ functions from polynomial fitting (in fact, you can use those as shape functions).
Typical shape function families: Lagrange, Hermite, Hierarchic, Monomial, Clough-Toucher - MOOSE has support for all of these.
Lagrange shape functions are the most common. - They are interpolary at the nodes, i.e., the coefficients correspond to the values of the functions at the nodes.

Example 1D Shape Functions

Linear Lagrange

Quadratic Lagrange

Cubic Lagrange

Cubic Hermite

2D Lagrange Shape Functions

Example bi-quadratic basis functions defined on the Quad9 element:

$var element = document.getElementById("moose-equation-c9e5934e-9dce-4413-9ea4-5d4c319de5da");katex.render("\\psi_0", element, {displayMode:false,throwOnError:false});$ is associated to a "corner" node, it is zero on the opposite edges.
$var element = document.getElementById("moose-equation-07f8682b-8713-4662-bb68-fd7fcdec87d3");katex.render("\\psi_4", element, {displayMode:false,throwOnError:false});$ is associated to a "mid-edge" node, it is zero on all other edges.
$var element = document.getElementById("moose-equation-efd0db66-3982-4a99-a724-765e64fff439");katex.render("\\psi_8", element, {displayMode:false,throwOnError:false});$ is associated to the "center" node, it is symmetric and $var element = document.getElementById("moose-equation-0cefd094-93db-4a96-a04f-6f0e4977ee18");katex.render("\\geq 0", element, {displayMode:false,throwOnError:false});$ on the element.

$var element = document.getElementById("moose-equation-7f39f565-b332-401e-8548-09024fcf45de");katex.render("\\psi_0", element, {displayMode:false,throwOnError:false});$

$var element = document.getElementById("moose-equation-82b739f1-3b36-4679-b9bc-5e00e44c6a5a");katex.render("\\psi_4", element, {displayMode:false,throwOnError:false});$

$var element = document.getElementById("moose-equation-574cd9f5-a633-4aa4-a7b9-ff0b72798d28");katex.render("\\psi_8", element, {displayMode:false,throwOnError:false});$

Numerical Integration

The only remaining non-discretized parts of the weak form are the integrals.
We split the domain integral into a sum of integrals over elements: $var element = document.getElementById("moose-equation-071605a9-dd6e-4e64-a61c-eb3a875f3084");katex.render("\\int_{\\Omega} f(\\vec{x}) \\;\\text{d}\\vec{x} = \\sum_e \\int_{\\Omega_e} f(\\vec{x}) \\;\\text{d}\\vec{x}", element, {displayMode:false,throwOnError:false});$
Through a change of variables, the element integrals are mapped to integrals over the "reference" elements $var element = document.getElementById("moose-equation-db6f09a1-628d-4c15-8725-74f29d3180fc");katex.render("\\hat{\\Omega}_e", element, {displayMode:false,throwOnError:false});$ . $var element = document.getElementById("moose-equation-5f089804-224a-44e1-936a-6580422ca256");katex.render("\\sum_e \\int_{\\Omega_e} f(\\vec{x}) \\;\\text{d}\\vec{x} = \\sum_e \\int_{\\hat{\\Omega}_e} f(\\vec{\\xi}) \\left|\\mathcal{J}_e\\right| \\;\\text{d}\\vec{\\xi}", element, {displayMode:false,throwOnError:false});$
$var element = document.getElementById("moose-equation-394133b9-fcce-4ade-94e2-b3160ef42798");katex.render("\\mathcal{J}_e", element, {displayMode:false,throwOnError:false});$ is the Jacobian of the map from the physical element to the reference element.
To approximate the reference element integrals numerically, we use quadrature (typically "Gaussian Quadrature"): $var element = document.getElementById("moose-equation-694bfc36-09a3-4f31-abef-e41026c83c48");katex.render("\\sum_e \\int_{\\hat{\\Omega}_e} f(\\vec{\\xi}) \\left|\\mathcal{J}_e\\right| \\;\\text{d}\\vec{\\xi} \\approx \\sum_e \\sum_{q} w_{q} f( \\vec{x}_{q}) \\left|\\mathcal{J}_e(\\vec{x}_{q})\\right|", element, {displayMode:false,throwOnError:false});$
$var element = document.getElementById("moose-equation-30150edb-694f-4fcc-a307-61d6330a1198");katex.render("\\vec{x}_{q}", element, {displayMode:false,throwOnError:false});$ is the spatial location of the $var element = document.getElementById("moose-equation-60520637-4286-4a01-883f-2255c1ed4b64");katex.render("q", element, {displayMode:false,throwOnError:false});$ th quadrature point and $var element = document.getElementById("moose-equation-435ede9d-db30-46c6-886c-248f745e82ee");katex.render("w_{q}", element, {displayMode:false,throwOnError:false});$ is its associated weight.
MOOSE handles multiplication by the Jacobian and the weight automatically, thus your Kernel is only responsible for computing the $var element = document.getElementById("moose-equation-4084b1f4-389a-431f-b724-af5cc7403cbc");katex.render("f(\\vec{x}_{q})", element, {displayMode:false,throwOnError:false});$ part of the integrand.
Under certain common situations, the quadrature approximation is exact! - For example, in 1 dimension, Gaussian Quadrature can exactly integrate polynomials of order $var element = document.getElementById("moose-equation-ed77c4f2-f8e9-494b-a2d7-e17ed333c20d");katex.render("2n-1", element, {displayMode:false,throwOnError:false});$ with $var element = document.getElementById("moose-equation-145de6d7-7742-4e8a-b152-a75b522808d7");katex.render("n", element, {displayMode:false,throwOnError:false});$ quadrature points.
Note that sampling $var element = document.getElementById("moose-equation-70ac7e53-0e29-40af-a342-1f654b32c3a6");katex.render("u_h", element, {displayMode:false,throwOnError:false});$ at the quadrature points yields: $var element = document.getElementById("moose-equation-81a912f7-8ce4-4680-87e8-ceb43e316ffe");katex.render("\\begin{aligned} u(\\vec{x}_{q}) &\\approx u_h(\\vec{x}_{q}) = \\sum u_j \\phi_j(\\vec{x}_{q}) \\\\ \\nabla u (\\vec{x}_{q}) &\\approx \\nabla u_h(\\vec{x}_{q}) = \\sum u_j \\nabla \\phi_j(\\vec{x}_{q})\\end{aligned}", element, {displayMode:false,throwOnError:false});$
And our weak form becomes: $var element = document.getElementById("moose-equation-590161a2-8b39-4b94-9772-6da8b346f057");katex.render("\\begin{aligned} R_i(u_h) &= \\sum_e \\sum_{q} w_{q} \\left|\\mathcal{J}_e\\right|\\left[ \\nabla\\psi_i\\cdot k \\nabla u_h + \\psi_i \\left(\\vec\\beta\\cdot \\nabla u_h \\right) - \\psi_i f \\right](\\vec{x}_{q}) \\\\ &- \\sum_f \\sum_{q_{face}} w_{q_{face}} \\left|\\mathcal{J}_f\\right| \\left[\\psi_i k \\nabla u_h \\cdot \\vec{n} \\right](\\vec x_{q_{face}}) \\end{aligned}", element, {displayMode:false,throwOnError:false});$
The second sum is over boundary faces, $var element = document.getElementById("moose-equation-5bb477fd-4fed-4cd6-ad90-aebb4c37583b");katex.render("f", element, {displayMode:false,throwOnError:false});$ .
MOOSE Kernels must provide each of the terms in square brackets (evaluated at $var element = document.getElementById("moose-equation-fb6004ce-92f1-4296-8197-0b0e433e60e9");katex.render("\\vec{x}_{q}", element, {displayMode:false,throwOnError:false});$ or $var element = document.getElementById("moose-equation-652d0a3c-6378-42d0-82d7-4fa242ff1d9b");katex.render("\\vec x_{q_{face}}", element, {displayMode:false,throwOnError:false});$ as necessary).

Input Parameters

linear_sys_namesThe linear system names
C++ Type:std::vector<LinearSystemName>
Unit:(no unit assumed)
Controllable:No
Description:The linear system names
not_zeroed_tag_vectorsExtra vector tags which the sytem will not zero when other vector tags are zeroed. The outer index is for which nonlinear system the extra tag vectors should be added for
C++ Type:std::vector<std::vector<TagName>>
Unit:(no unit assumed)
Controllable:No
Description:Extra vector tags which the sytem will not zero when other vector tags are zeroed. The outer index is for which nonlinear system the extra tag vectors should be added for
regard_general_exceptions_as_errorsFalseIf we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling, immediately error instead of allowing the time step to be cut
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:If we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling, immediately error instead of allowing the time step to be cut
solveTrueWhether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:Yes
Description:Whether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything

Optional Parameters

allow_initial_conditions_with_restartFalseTrue to allow the user to specify initial conditions when restarting. Initial conditions can override any restarted field
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:True to allow the user to specify initial conditions when restarting. Initial conditions can override any restarted field
force_restartFalseEXPERIMENTAL: If true, a sub_app may use a restart file instead of using of using the master backup file
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:EXPERIMENTAL: If true, a sub_app may use a restart file instead of using of using the master backup file
restart_file_baseFile base name used for restart (e.g. / or /LATEST to grab the latest file available)
C++ Type:FileNameNoExtension
Unit:(no unit assumed)
Controllable:No
Description:File base name used for restart (e.g. / or /LATEST to grab the latest file available)

Restart Parameters

allow_invalid_solutionFalseSet to true to allow convergence even though the solution has been marked as 'invalid'
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to true to allow convergence even though the solution has been marked as 'invalid'
immediately_print_invalid_solutionFalseWhether or not to report invalid solution warnings at the time the warning is produced instead of after the calculation
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether or not to report invalid solution warnings at the time the warning is produced instead of after the calculation
show_invalid_solution_consoleTrueSet to true to show the invalid solution occurance summary in console
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to true to show the invalid solution occurance summary in console

Solution Validity Control Parameters

boundary_restricted_elem_integrity_checkTrueSet to false to disable checking of boundary restricted elemental object variable dependencies, e.g. are the variable dependencies defined on the selected boundaries?
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to false to disable checking of boundary restricted elemental object variable dependencies, e.g. are the variable dependencies defined on the selected boundaries?
boundary_restricted_node_integrity_checkTrueSet to false to disable checking of boundary restricted nodal object variable dependencies, e.g. are the variable dependencies defined on the selected boundaries?
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to false to disable checking of boundary restricted nodal object variable dependencies, e.g. are the variable dependencies defined on the selected boundaries?
check_uo_aux_stateFalseTrue to turn on a check that no state presents during the evaluation of user objects and aux kernels
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:True to turn on a check that no state presents during the evaluation of user objects and aux kernels
error_on_jacobian_nonzero_reallocationFalseThis causes PETSc to error if it had to reallocate memory in the Jacobian matrix due to not having enough nonzeros
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:This causes PETSc to error if it had to reallocate memory in the Jacobian matrix due to not having enough nonzeros
fv_bcs_integrity_checkTrueSet to false to disable checking of overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to false to disable checking of overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset
kernel_coverage_block_listList of subdomains for kernel coverage check. The meaning of this list is controlled by the parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
C++ Type:std::vector<SubdomainName>
Unit:(no unit assumed)
Controllable:No
Description:List of subdomains for kernel coverage check. The meaning of this list is controlled by the parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
kernel_coverage_checkTRUEControls, if and how a kernel subdomain coverage check is performed. With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' will disable the check for all subdomains. To exclude a predefined set of subdomains 'SKIP_LIST' is to be used, while the subdomains to skip are to be defined in the parameter 'kernel_coverage_block_list'. To limit the check to a list of subdomains, 'ONLY_LIST' is to be used (again, using the parameter 'kernel_coverage_block_list').
Default:TRUE
C++ Type:MooseEnum
Unit:(no unit assumed)
Options:FALSE, TRUE, OFF, ON, SKIP_LIST, ONLY_LIST
Controllable:No
Description:Controls, if and how a kernel subdomain coverage check is performed. With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' will disable the check for all subdomains. To exclude a predefined set of subdomains 'SKIP_LIST' is to be used, while the subdomains to skip are to be defined in the parameter 'kernel_coverage_block_list'. To limit the check to a list of subdomains, 'ONLY_LIST' is to be used (again, using the parameter 'kernel_coverage_block_list').
material_coverage_block_listList of subdomains for material coverage check. The meaning of this list is controlled by the parameter 'material_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
C++ Type:std::vector<SubdomainName>
Unit:(no unit assumed)
Controllable:No
Description:List of subdomains for material coverage check. The meaning of this list is controlled by the parameter 'material_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
material_coverage_checkTRUEControls, if and how a material subdomain coverage check is performed. With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' will disable the check for all subdomains. To exclude a predefined set of subdomains 'SKIP_LIST' is to be used, while the subdomains to skip are to be defined in the parameter 'material_coverage_block_list'. To limit the check to a list of subdomains, 'ONLY_LIST' is to be used (again, using the parameter 'material_coverage_block_list').
Default:TRUE
C++ Type:MooseEnum
Unit:(no unit assumed)
Options:FALSE, TRUE, OFF, ON, SKIP_LIST, ONLY_LIST
Controllable:No
Description:Controls, if and how a material subdomain coverage check is performed. With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' will disable the check for all subdomains. To exclude a predefined set of subdomains 'SKIP_LIST' is to be used, while the subdomains to skip are to be defined in the parameter 'material_coverage_block_list'. To limit the check to a list of subdomains, 'ONLY_LIST' is to be used (again, using the parameter 'material_coverage_block_list').
material_dependency_checkTrueSet to false to disable material dependency check
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to false to disable material dependency check
skip_nl_system_checkFalseTrue to skip the NonlinearSystem check for work to do (e.g. Make sure that there are variables to solve for).
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:True to skip the NonlinearSystem check for work to do (e.g. Make sure that there are variables to solve for).

Simulation Checks Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Unit:(no unit assumed)
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
default_ghostingFalseWhether or not to use libMesh's default amount of algebraic and geometric ghosting
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether or not to use libMesh's default amount of algebraic and geometric ghosting
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

extra_tag_matricesExtra matrices to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which nonlinear system the extra tag vectors should be added for
C++ Type:std::vector<std::vector<TagName>>
Unit:(no unit assumed)
Controllable:No
Description:Extra matrices to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which nonlinear system the extra tag vectors should be added for
extra_tag_solutionsExtra solution vectors to add to the system that can be used by objects for coupling variable values stored in them.
C++ Type:std::vector<TagName>
Unit:(no unit assumed)
Controllable:No
Description:Extra solution vectors to add to the system that can be used by objects for coupling variable values stored in them.
extra_tag_vectorsExtra vectors to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which nonlinear system the extra tag vectors should be added for
C++ Type:std::vector<std::vector<TagName>>
Unit:(no unit assumed)
Controllable:No
Description:Extra vectors to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which nonlinear system the extra tag vectors should be added for

Tagging Parameters

identify_variable_groups_in_nlTrueWhether to identify variable groups in nonlinear systems. This affects dof ordering
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether to identify variable groups in nonlinear systems. This affects dof ordering
ignore_zeros_in_jacobianFalseDo not explicitly store zero values in the Jacobian matrix if true
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Do not explicitly store zero values in the Jacobian matrix if true
nl_sys_namesnl0 The nonlinear system names
Default:nl0
C++ Type:std::vector<NonlinearSystemName>
Unit:(no unit assumed)
Controllable:No
Description:The nonlinear system names
previous_nl_solution_requiredFalseTrue to indicate that this calculation requires a solution vector for storing the previous nonlinear iteration.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:True to indicate that this calculation requires a solution vector for storing the previous nonlinear iteration.
use_nonlinearTrueDetermines whether to use a Nonlinear vs a Eigenvalue system (Automatically determined based on executioner)
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Determines whether to use a Nonlinear vs a Eigenvalue system (Automatically determined based on executioner)

Nonlinear System(S) Parameters

near_null_space_dimension0The dimension of the near nullspace
Default:0
C++ Type:unsigned int
Unit:(no unit assumed)
Controllable:No
Description:The dimension of the near nullspace
null_space_dimension0The dimension of the nullspace
Default:0
C++ Type:unsigned int
Unit:(no unit assumed)
Controllable:No
Description:The dimension of the nullspace
transpose_null_space_dimension0The dimension of the transpose nullspace
Default:0
C++ Type:unsigned int
Unit:(no unit assumed)
Controllable:No
Description:The dimension of the transpose nullspace

Null Space Removal Parameters

parallel_barrier_messagingFalseDisplays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false)
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Displays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false)
verbose_multiappsFalseSet to True to enable verbose screen printing related to MultiApps
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set to True to enable verbose screen printing related to MultiApps
verbose_setupfalseSet to 'true' to have the problem report on any object created. Set to 'extra' to also display all parameters.
Default:false
C++ Type:MooseEnum
Unit:(no unit assumed)
Options:false, true, extra
Controllable:No
Description:Set to 'true' to have the problem report on any object created. Set to 'extra' to also display all parameters.

note

When "check_uo_aux_state" is set to true, MOOSE will evaluate user objects (including all postprocessors and vector postprocessors) and auxiliary kernels on every execute flag except linear twice. It then compares the results after two evaluations including the auxiliary system solutions and all the real reporter values added by user objects. When MOOSE sees a difference, it will issue an error indicating that there are unresolved dependencies during the evaluation because otherwise the results should only depend on primary solutions and should not change. MOOSE also prints the details about the difference to help users removing the states caused by these unresolved dependencies.

Verbosity Parameters

References

No citations exist within this document.

Convenience Zeros
Selective Reinit
Finite Element Concepts
Input Parameters
References