# Built-in Executioners

• There are two main types of Executioners: Steady and Transient.
• MOOSE provides a number of built-in executioners, but you can extend this system and add your own.

• Steady-state executioners generally solve the nonlinear system just once.
• However, our steady-state executioner can solve the nonlinear system multiple times while adaptively refining the mesh to improve the solution.

# Common Executioner Options

• There are a number of options that appear in the executioner block and are used to control the solver. The best way to view these is through peacock. Here are a few common options:
option definition
l_tol Linear Tolerance
l_max_its Max Linear Iterations
nl_rel_tol Nonlinear Relative Tolerance
nl_abs_tol Nonlinear Absolute Tolerance
nl_max_its Max Nonlinear Iterations

# Transient Executioners

• Transient executioners solve the nonlinear system at least once per time step.
• Some frequently-used Transient Executioner options
option definition
dt Starting time step size
num_steps Number of time steps
start_time The start time of the simulation
end_time The end time of the simulation
scheme Time integration scheme (discussed next)
option definition
trans_ss_check Whether to try and detect achievement of steady-state (Default = false)
ss_check_tol Used for determining a steady-state; Compared against the difference in solution vectors between current and old time steps (Default = 1e-8)

Note that if you have things like piecewise-constant transient forcing functions, you may achieve temporary steady-states and may not want to terminate the simulation at those points. In this case a better solution may be to set an nl_abs_tol which will allow your simulation to converge in 0 non-linear iterations during periodic steady-states, but will also allow your simulation to solve as usual when your forcing functions are perturbed.

# Transient Analysis

• MOOSE provides the following implicit TimeIntegrators:

1. Backward Euler (default)
2. BDF2
3. Crank-Nicolson
4. Implicit-Euler
5. Implicit Midpoint (implemented as two-stage RK method)
6. Diagonally-Implicit Runge-Kutta (DIRK) methods of order 2 and 3.
• And these explicit TimeIntegrators:

1. Explicit-Euler
2. Various two-stage explicit Runge-Kutta methods (Midpoint, Heun, Ralston, TVD)
• Each one of these supports adaptive time stepping.

• They are all accessed via the TimeDerivative Kernel object.

# Example 6

Look at Example 6

EigenExecutioner