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 Executioner

  • 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)
  • Advanced Transient Executioner options
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.

Custom Time Kernel

  • If you need to provide a coefficient for the transient term (such as $$$\rho c_p$$$ in classical heat conduction) inherit from the TimeDerivative Kernel in MOOSE.
  • Then, in computeQpResidual/Jacobian() return the product of your coefficient and TimeDerivative::computeQpResidual/Jacobian().


Summary of input file syntax changes for transient analysis

  • Add appropriate TimeDerivative Kernels.
  • Switch your executioner type to "Transient"
  • Add a few typical parameters to the Executioner block
    • Real time: The start time for the simulation.
    • Real dt: The initial time step size.
    • string scheme: Time integrator scheme
      • 'crank-nicolson'
      • 'backward-euler' -- default if you do not specify the scheme
      • 'bdf2'

Convergence Rates

  • Consider the test problem: $$$$\begin{array}{rl} \frac{\partial u}{\partial t} - \nabla^2 u &= f \\ u(t=0)&= u_0 \\ \left. u \right|_{\partial \Omega} &= u_D \end{array}$$$$ for $$$t=(0,T]$$$, and $$$\Omega=(-1,1)^2$$$

  • $$$f$$$ is chosen so the exact solution is given by $$$u = t^3 (x^2 + y^2)$$$

  • $$$u_0$$$ and $$$u_D$$$ are the initial and Dirichlet boundary conditions corresponding to this exact solution.



Example 6

Look at Example 6

Eigenvalue Executioner