VectorTimeDerivative

The time derivative operator with the weak form of $var element = document.getElementById("moose-equation-911054cf-2551-488e-af4f-234359a1d608");katex.render("(\\vec{\\psi_i}, \\frac{\\partial \\vec{u_h}}{\\partial t})", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ .

Overview

The VectorTimeDerivative kernel implements a simple time derivative for the domain $var element = document.getElementById("moose-equation-57c35155-2ad2-4b45-8277-cfde0dd14b37");katex.render("\\Omega", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ given by

$var element = document.getElementById("moose-equation-e9b81405-f1d1-4f3e-b06e-f7f7177ce41a");katex.render("\\underbrace{\\frac{\\partial \\vec{u}}{\\partial t}}_{\\textrm{VectorTimeDerivative}} + \\sum_{i=1}^n \\beta_i = 0 \\in \\Omega.", element, {displayMode:true,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ where the second term on the left hand side corresponds to the strong forms of other kernels. The corresponding VectorTimeDerivative weak form using inner-product notation is

$var element = document.getElementById("moose-equation-f07910b5-853f-4f06-920d-ee656bd819d3");katex.render("R_i(\\vec{u}_h) = (\\vec{\\psi}_i, \\frac{\\partial \\vec{u_h}}{\\partial t}) \\quad \\forall \\vec{\\psi}_i,", element, {displayMode:true,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ where $var element = document.getElementById("moose-equation-a3432adb-3417-4c7e-8281-d27f1d309dfc");katex.render("\\vec{u}_h", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ is the approximate solution and $var element = document.getElementById("moose-equation-2285e437-6779-4794-b164-52cf0edbd6a2");katex.render("\\vec{\\psi}_i", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ is a finite element test function.

The Jacobian is given by

$var element = document.getElementById("moose-equation-1b45a077-1743-428e-bbbf-b6c6d6390e73");katex.render("\\frac{\\partial R_i(\\vec{u}_h)}{\\partial u_j} = (\\vec{\\psi}_i, a\\vec{\\phi}_j).", element, {displayMode:true,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ where $var element = document.getElementById("moose-equation-2ef66788-ebad-4fcd-b5ad-bb42af516313");katex.render("a", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ is referred to as du_dot_du in MOOSE syntax. More information about time kernels can be found on the Kernels description page.

Example Input File Syntax

Time derivative terms are ubiquitous in any transient simulation. The kernel block for a transient diffusion problem that demonstrates the VectorTimeDerivative syntax is shown below:

[Kernels]
  [./diff]
    type = VectorDiffusion
    variable = u
  [../]
  [./time]
    type = VectorTimeDerivative
    variable = u
  [../]
[]

/opt/civet/build_0/moose/test/tests/kernels/transient_vector_diffusion/transient_vector_diffusion.i

[Mesh]
  [./generator]
    type = GeneratedMeshGenerator
    dim = 2
    nx = 10
    ny = 10
  [../]
  [./block1]
    type = SubdomainBoundingBoxGenerator
    input = generator
    bottom_left = '0 0 -1'
    top_right = '1 1 1'
    block_id = 1
  [../]
  [./block2]
    type = SubdomainBoundingBoxGenerator
    input = block1
    bottom_left = '0.33 0.33 -1'
    top_right = '0.67 0.67 1'
    block_id = 2
  [../]
[]

[Variables]
  [./u]
    family = LAGRANGE_VEC
  [../]
[]

[ICs]
  [./u]
    type = VectorConstantIC
    variable = u
    x_value = 1
    y_value = 2
    z_value = 3
    block = 2
  [../]
[]

[Kernels]
  [./diff]
    type = VectorDiffusion
    variable = u
  [../]
  [./time]
    type = VectorTimeDerivative
    variable = u
  [../]
[]

[Executioner]
  type = Transient
  num_steps = 20
  dt = 0.01
  solve_type = NEWTON
  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'
[]

[Outputs]
  exodus = true
[]

Input Parameters

variableThe name of the variable that this Kernel operates on
C++ Type:NonlinearVariableName
Options:
Description:The name of the variable that this Kernel operates on

Required Parameters

blockThe list of block ids (SubdomainID) that this object will be applied
C++ Type:std::vector
Options:
Description:The list of block ids (SubdomainID) that this object will be applied
displacementsThe displacements
C++ Type:std::vector
Options:
Description:The displacements
lumpingFalseTrue for mass matrix lumping, false otherwise
Default:False
C++ Type:bool
Options:
Description:True for mass matrix lumping, false otherwise

Optional Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector
Options:
Description:Adds user-defined labels for accessing object parameters via control logic.
diag_save_inThe name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
C++ Type:std::vector
Options:
Description:The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Options:
Description:Set the enabled status of the MooseObject.
implicitTrueDetermines whether this object is calculated using an implicit or explicit form
Default:True
C++ Type:bool
Options:
Description:Determines whether this object is calculated using an implicit or explicit form
save_inThe name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
C++ Type:std::vector
Options:
Description:The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
seed0The seed for the master random number generator
Default:0
C++ Type:unsigned int
Options:
Description:The seed for the master random number generator
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Options:
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

extra_matrix_tagsThe extra tags for the matrices this Kernel should fill
C++ Type:std::vector
Options:
Description:The extra tags for the matrices this Kernel should fill
extra_vector_tagsThe extra tags for the vectors this Kernel should fill
C++ Type:std::vector
Options:
Description:The extra tags for the vectors this Kernel should fill
matrix_tagssystem timeThe tag for the matrices this Kernel should fill
Default:system time
C++ Type:MultiMooseEnum
Options:nontime system time
Description:The tag for the matrices this Kernel should fill
vector_tagstimeThe tag for the vectors this Kernel should fill
Default:time
C++ Type:MultiMooseEnum
Options:nontime time
Description:The tag for the vectors this Kernel should fill

Tagging Parameters

Input Files

test/tests/kernels/transient_vector_diffusion/transient_vector_diffusion.i
test/tests/kernels/vector_dot_dot/vector_test.i
test/tests/kernels/coupled_time_derivative/vector_coupled_time_derivative_test.i

test/tests/kernels/transient_vector_diffusion/transient_vector_diffusion.i

[Mesh]
  [./generator]
    type = GeneratedMeshGenerator
    dim = 2
    nx = 10
    ny = 10
  [../]
  [./block1]
    type = SubdomainBoundingBoxGenerator
    input = generator
    bottom_left = '0 0 -1'
    top_right = '1 1 1'
    block_id = 1
  [../]
  [./block2]
    type = SubdomainBoundingBoxGenerator
    input = block1
    bottom_left = '0.33 0.33 -1'
    top_right = '0.67 0.67 1'
    block_id = 2
  [../]
[]

[Variables]
  [./u]
    family = LAGRANGE_VEC
  [../]
[]

[ICs]
  [./u]
    type = VectorConstantIC
    variable = u
    x_value = 1
    y_value = 2
    z_value = 3
    block = 2
  [../]
[]

[Kernels]
  [./diff]
    type = VectorDiffusion
    variable = u
  [../]
  [./time]
    type = VectorTimeDerivative
    variable = u
  [../]
[]

[Executioner]
  type = Transient
  num_steps = 20
  dt = 0.01
  solve_type = NEWTON
  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'
[]

[Outputs]
  exodus = true
[]

test/tests/kernels/vector_dot_dot/vector_test.i

# Tests calculation of first and second time derivative
# of a coupled vector variable in a material
# a_vec(x,y,z,t) = [t*(t*x + y), t*y, 0]
# a_vec_dot(x,y,z,t) = [2*t*x + y, y, 0]
# a_vec_dot_dot(x,y,z,t) = [2*x, 0, 0]
#
# IMPORTANT NOTE:
# Currently, this test produces a_vec_dot and a_vec_dot_dot that contains oscillations over time.
# This is a known by-product of Newmark Beta time integration (see the Newmark Beta documentation),
# but as of Summer 2019, there is no alternative time integrator in MOOSE that can dampen these
# oscillations. This test is used as coverage for the function call coupledVectorDotDot.

[Mesh]
  type = GeneratedMesh
  dim = 2
  xmin = 0
  xmax = 4
  ymin = 0
  ymax = 4
  nx = 8
  ny = 8
[]

[Functions]
  [a_fn]
    type = ParsedVectorFunction
    value_x = 't * (t * x + y)'
    value_y = 't * y'
    value_z = 0
  []
[]

[AuxVariables]
  [a]
    family = LAGRANGE_VEC
    order = FIRST
  []
[]

[AuxKernels]
  [a_ak]
    type = VectorFunctionAux
    variable = a
    function = a_fn
  []
[]

[Materials]
  [cm]
    type = VectorCoupledValuesMaterial
    variable = a
  []
[]

[Variables]
  [u]   # u is zero
    family = LAGRANGE_VEC
    order = FIRST
  []
[]

[Kernels]
  [td]
    type = VectorTimeDerivative
    variable = u
  []
[]

[Executioner]
  type = Transient
  dt = 1
  num_steps = 3

  [TimeIntegrator]
    type = NewmarkBeta
  []
[]

[Outputs]
  [./out]
    type = Exodus
    output_material_properties = true
    show_material_properties = 'a_value a_dot a_dot_dot a_dot_du a_dot_dot_du'
  [../]
[]

test/tests/kernels/coupled_time_derivative/vector_coupled_time_derivative_test.i

###########################################################
# This is a simple test of the VectorCoupledTimeDerivative kernel.
# The expected solution for the vector variable v is
# v_x(x) = 1/2 * (x^2 + x)
# v_y(x) = 1/2 * (x^2 + x)
###########################################################

[Mesh]
  type = GeneratedMesh
  nx = 5
  ny = 5
  dim = 2
[]

[Variables]
  [./u]
    family = LAGRANGE_VEC
  [../]
  [./v]
    family = LAGRANGE_VEC
  [../]
[]

[Kernels]
  [./time_u]
    type = VectorTimeDerivative
    variable = u
  [../]
  [./fn_u]
    type = VectorBodyForce
    variable = u
    function_x = 1
    function_y = 1
  [../]
  [./time_v]
    type = VectorCoupledTimeDerivative
    variable = v
    v = u
  [../]
  [./diff_v]
    type = VectorDiffusion
    variable = v
  [../]
[]

[BCs]
  [./left]
    type = VectorDirichletBC
    variable = v
    boundary = 'left'
    values = '0 0 0'
  [../]
  [./right]
    type = VectorDirichletBC
    variable = v
    boundary = 'right'
    values = '1 1 0'
  [../]
[]

[Executioner]
  type = Transient
  num_steps = 1
  solve_type = 'NEWTON'
[]

[Outputs]
  exodus = true
[]

Overview
Example Input File Syntax
Input Parameters
Input Files

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools