Heun

construction:Undocumented Class

The Heun has not been documented. The content listed below should be used as a starting point for documenting the class, which includes the typical automatic documentation associated with a MooseObject; however, what is contained is ultimately determined by what is necessary to make the documentation clear for users.


# Heun

!syntax description /Executioner/TimeIntegrator/Heun

## Overview

!! Replace these lines with information regarding the Heun object.

## Example Input File Syntax

!! Describe and include an example of how to use the Heun object.

!syntax parameters /Executioner/TimeIntegrator/Heun

!syntax inputs /Executioner/TimeIntegrator/Heun

!syntax children /Executioner/TimeIntegrator/Heun

Heun's (aka improved Euler) time integration method.

Input Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Options:
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Options:
Description:Set the enabled status of the MooseObject.

Input Files

(test/tests/time_integrators/convergence/explicit_convergence.i)
(test/tests/time_integrators/scalar/scalar.i)

(test/tests/time_integrators/convergence/explicit_convergence.i)

[Mesh]
  type = GeneratedMesh
  dim  = 2
  xmin = -1
  xmax = 1
  ymin = -1
  ymax = 1
  nx   = 4
  ny   = 4
  elem_type = QUAD9
[]

[Variables]
  active = 'u'

  [./u]
    order = SECOND
    family = LAGRANGE

    [./InitialCondition]
      type = ConstantIC
      value = 0
    [../]
  [../]
[]

[Functions]
  [./exact_fn]
    type = ParsedFunction
    value = t*t*t*((x*x)+(y*y))
  [../]

  [./forcing_fn]
    type = ParsedFunction
    value = 3*t*t*((x*x)+(y*y))-(4*t*t*t)
  [../]
[]

[Kernels]
  active = 'diff ie ffn'

  [./ie]
    type = TimeDerivative
    variable = u
  [../]

  [./diff]
    type = Diffusion
    variable = u
    implicit = false
  [../]

  [./ffn]
    type = BodyForce
    variable = u
    function = forcing_fn
    implicit = false
  [../]
[]

[BCs]
  [./all]
    type = FunctionDirichletBC
    variable = u
    boundary = '0 1 2 3'
    function = exact_fn
  [../]
[]

[Postprocessors]
  [./l2_err]
    type = ElementL2Error
    variable = u
    function = exact_fn
  [../]
[]

[Executioner]
  type = Transient

  # We are solving only mass matrices in this problem.  The Jacobi
  # preconditioner is a bit faster than ILU or AMG for this.
  petsc_options_iname = '-pc_type'
  petsc_options_value = 'jacobi'

  start_time = 0.0
  end_time = 0.03125
  dt = 0.00390625

  [./TimeIntegrator]
    type = Heun
  [../]

   # For explicit methods, we use the LINEAR solve type.
   solve_type = 'LINEAR'
   l_tol = 1e-13
[]

[Outputs]
  execute_on = 'initial timestep_end'
  exodus = true
  csv = true
[]

(test/tests/time_integrators/scalar/scalar.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  xmin = 0
  xmax = 1
  ymin = 0
  ymax = 1
  nx = 1
  ny = 1
  elem_type = QUAD4
[]

[Variables]
  [./n]
    family = SCALAR
    order = FIRST
    initial_condition = 1
  [../]
[]

[ScalarKernels]
  [./dn]
    type = ODETimeDerivative
    variable = n
  [../]
  [./ode1]
    type = ParsedODEKernel
    function = '-n'
    variable = n
    # implicit = false
  [../]
[]

[Executioner]
  type = Transient
  [./TimeIntegrator]
    # type = ImplicitEuler
    # type = BDF2
    type = CrankNicolson
    # type = ImplicitMidpoint
    # type = LStableDirk2
    # type = LStableDirk3
    # type = LStableDirk4
    # type = AStableDirk4
    #
    # Explicit methods
    # type = ExplicitEuler
    # type = ExplicitMidpoint
    # type = Heun
    # type = Ralston
  [../]
  start_time = 0
  end_time = 1
  dt = 0.001
  dtmin = 0.001 # Don't allow timestep cutting
  solve_type = 'PJFNK'
  nl_max_its = 2
  nl_abs_tol = 1.e-12 # This is an ODE, so nl_abs_tol makes sense.
[]

[Functions]
  [./exact_solution]
    type = ParsedFunction
    value = exp(t)
  [../]
[]

[Postprocessors]
  [./error_n]
    # Post processor that computes the difference between the computed
    # and exact solutions.  For the exact solution used here, the
    # error at the final time should converge at O(dt^p), where p is
    # the order of the method.
    type = ScalarL2Error
    variable = n
    function = exact_solution
    # final is not currently supported for Postprocessor execute_on...
    # execute_on = 'final'
  [../]
[]

[Outputs]
  csv = true
[]

Input Parameters
Input Files

Install MOOSE

New Users

Examples and Tutorials

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools

INL Applications and Remote Access

Heun

Input Parameters

Input Files