TensorNeumannBC

Neumann boundary condition (du/dn = flux) on a non-periodic domain face.

Overview

Imposes $var element = document.getElementById("moose-equation-a6bfb7ae-ec4d-45a8-a9c4-3f3aa4ede9b5");katex.render("\\partial u / \\partial n =", element, {displayMode:false,throwOnError:false});$ "flux" on one face of a non-periodic direction, with $var element = document.getElementById("moose-equation-5f5dbc51-6215-409a-bfa6-bc038d9c01d2");katex.render("n", element, {displayMode:false,throwOnError:false});$ the outward normal. It is TensorRobinBC with $var element = document.getElementById("moose-equation-f63bffa2-0f9e-4d4c-b999-6e4445db0373");katex.render("a = 0", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-f0c701b2-ed70-4244-b78a-51e1161f07ee");katex.render("b = 1", element, {displayMode:false,throwOnError:false});$ . The flux can vary along the face, from "flux_function" or "flux_buffer" (see the BCs system).

Example Input File Syntax

[TensorComputes<<<{"href": "../../syntax/TensorComputes/index.html"}>>>]
  [BCs<<<{"href": "../../syntax/TensorComputes/BCs/index.html"}>>>]
    [left]
      type = TensorDirichletBC<<<{"description": "Dirichlet boundary condition (u = value) on a non-periodic domain face.", "href": "TensorDirichletBC.html"}>>>
      variable<<<{"description": "The field this boundary condition applies to."}>>> = u
      boundary<<<{"description": "Which face of the domain this boundary condition applies to."}>>> = left
      value<<<{"description": "Prescribed value of the field on this face (u = value)."}>>> = 1
    []
    [right]
      type = TensorNeumannBC<<<{"description": "Neumann boundary condition (du/dn = flux) on a non-periodic domain face.", "href": "TensorNeumannBC.html"}>>>
      variable<<<{"description": "The field this boundary condition applies to."}>>> = u
      boundary<<<{"description": "Which face of the domain this boundary condition applies to."}>>> = right
      flux<<<{"description": "Prescribed outward normal flux on this face (du/dn = flux)."}>>> = 2
    []
  []
[]

Input Parameters

boundaryWhich face of the domain this boundary condition applies to.
C++ Type:MooseEnum
Options:left, right, bottom, top, front, back
Controllable:No
Description:Which face of the domain this boundary condition applies to.
variableThe field this boundary condition applies to.
C++ Type:std::string
Controllable:No
Description:The field this boundary condition applies to.

Required Parameters

flux0Prescribed outward normal flux on this face (du/dn = flux).
Default:0
C++ Type:Real
Unit:(no unit assumed)
Controllable:No
Description:Prescribed outward normal flux on this face (du/dn = flux).
flux_bufferBuffer whose first owned cell layer next to the face holds the outward normal flux along the face. The compute that writes it must evaluate it at the face position, not at the cell centres.
C++ Type:std::string
Controllable:No
Description:Buffer whose first owned cell layer next to the face holds the outward normal flux along the face. The compute that writes it must evaluate it at the face position, not at the cell centres.
flux_functionFunction giving the outward normal flux along the face, evaluated at the face position at the solve time.
C++ Type:FunctionName
Unit:(no unit assumed)
Controllable:No
Description:Function giving the outward normal flux along the face, evaluated at the face position at the solve time.

Optional Parameters

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

Advanced Parameters

Input Files

(test/tests/implicit_fd/bc_mms.i)
(test/tests/real_space/deep_ghost_faces.i)
(test/tests/real_space/bc_varying_laplacian.i)
(test/tests/real_space/neumann_linear.i)
(test/tests/real_space/neumann_conservation.i)
(test/tests/real_space/dirichlet_2d_corners.i)

(test/tests/real_space/neumann_linear.i)

# Nonzero-flux Neumann boundary condition: steady 1D diffusion with u(0) = 1
# (Dirichlet, left) and du/dn = 2 (Neumann, right) has the exact solution
# u = 1 + 2*x. Y is periodic, and the IC is not the steady profile.
[Domain]
  dim = 2
  nx = 20
  ny = 8
  parallel_mode = REAL_SPACE
  periodic_directions = 'Y'
  xmin = 0
  xmax = 1
  ymin = -1
  ymax = 1
[]

[Functions]
  [u_ic_func]
    type = ParsedFunction
    expression = '0.5'
  []
  [u_exact_func]
    type = ParsedFunction
    expression = '1 + 2 * x'
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = MooseFunctionTensor
      buffer = u
      function = u_ic_func
    []
  []
  [BCs]
    [left]
      type = TensorDirichletBC
      variable = u
      boundary = left
      value = 1
    []
    [right]
      type = TensorNeumannBC
      variable = u
      boundary = right
      flux = 2
    []
  []
  [Solve]
    [dt]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = dudt
    []
    [u_exact]
      type = MooseFunctionTensor
      buffer = u_exact
      function = u_exact_func
    []
    [diff]
      type = ParsedCompute
      buffer = diff
      expression = 'abs(u - u_exact)'
      inputs = 'u u_exact'
    []
  []
[]

[TensorSolver]
  type = RealSpaceForwardEuler
  buffer = u
  time_derivative = dudt
  substeps = 1000
[]

[Postprocessors]
  [max_error]
    type = TensorExtremeValuePostprocessor
    buffer = diff
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
[]

[Executioner]
  type = Transient
  # same grid and CFL margin as dirichlet_linear.i; the Neumann face makes the slowest
  # mode decay more slowly, so max_error needs 15 steps to plateau
  dt = 1
  num_steps = 15
[]

[Outputs]
  [out]
    type = CSV
  []
[]

(test/tests/implicit_fd/bc_mms.i)

# Implicit solve of u_t - D Laplacian(u) = f on the unit square with boundary faces, against the
# manufactured solution
#
#   u = g + tf t q,  g = cos(3 pi x / 2) cos(pi y) + x y,  q = x^2 - y^2,
#
# with tf = 0 for the steady problem -D Laplacian(u) = f and tf = 1 for backward Euler.
# q is harmonic, so f = tf q - D Laplacian(g) is independent of time and the backward Euler
# step makes no time error: the error is the spatial one, provided the boundary values are
# taken at the time of the unknown, t + dt (at t it would be of order dt).
#
# Each face has a different condition and value source:
#   left   (x = 0)  Dirichlet   u = cos(pi y) - tf t y^2                     function
#   right  (x = 1)  Robin       ra u + rb du/dx = c                         function
#                                                      or buffer (right_buffer, steady)
#   bottom (y = 0)  Neumann     du/dn = -du/dy = -x                          buffer
#   top    (y = 1)  Neumann     du/dn = du/dy = x - 2 tf t                   function
#                                                      or buffer (top_buffer, values at t)

D = 0.5
n = 32
stencil = 3
tf = 0
ops = 'lap'
num_steps = 1
dt = 0.05
# Robin coefficients on the right face (the 5-point stencil supports ra = 1, rb = 0 only)
ra = 1
rb = 1

[Domain]
  dim = 2
  nx = ${n}
  ny = ${n}
  xmax = 1
  ymax = 1
  parallel_mode = REAL_SPACE
[]

[Functions]
  [u_exact]
    type = ParsedFunction
    expression = 'cos(1.5*pi*x) * cos(pi*y) + x*y + ${tf} * t * (x^2 - y^2)'
  []
  [f_func]
    type = ParsedFunction
    # Laplacian(g) = -13/4 pi^2 cos(3 pi x / 2) cos(pi y)
    expression = '${tf} * (x^2 - y^2) + ${D} * 3.25 * pi^2 * cos(1.5*pi*x) * cos(pi*y)'
  []
  [right_c]
    type = ParsedFunction
    # on x = 1: u = y + tf t (1 - y^2), du/dx = 3/2 pi cos(pi y) + y + 2 tf t
    expression = '${ra} * (y + ${tf} * t * (1 - y^2)) + ${rb} * (1.5*pi*cos(pi*y) + y + 2 * ${tf} * t)'
  []
  [bottom_flux]
    type = ParsedFunction
    expression = '-x'
  []
  [top_flux]
    type = ParsedFunction
    expression = 'x - 2 * ${tf} * t'
  []
[]

[TensorBuffers]
  [u]
  []
  [dudt_u]
  []
  [lap_u]
  []
  [f]
  []
  [bottom_flux]
  []
  [right_c]
  []
  [top_flux]
  []
  [exact]
  []
  [diff]
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = MooseFunctionTensor
      buffer = u
      function = u_exact
    []
    [f_ic]
      type = MooseFunctionTensor
      buffer = f
      function = f_func
    []
    # a face value: depends on the tangential coordinate x only
    [bottom_flux]
      type = MooseFunctionTensor
      buffer = bottom_flux
      function = bottom_flux
    []
    [right_c]
      type = MooseFunctionTensor
      buffer = right_c
      function = right_c
    []
  []
  [BCs]
    active = 'left right bottom top'
    [left]
      type = TensorDirichletBC
      variable = u
      boundary = left
      value_function = u_exact
    []
    [right]
      type = TensorRobinBC
      variable = u
      boundary = right
      a = ${ra}
      b = ${rb}
      c_function = right_c
    []
    # the Robin c from a buffer instead (active = 'left right_buffer bottom top'), steady only
    [right_buffer]
      type = TensorRobinBC
      variable = u
      boundary = right
      a = ${ra}
      b = ${rb}
      c_buffer = right_c
    []
    [bottom]
      type = TensorNeumannBC
      variable = u
      boundary = bottom
      flux_buffer = bottom_flux
    []
    [top]
      type = TensorNeumannBC
      variable = u
      boundary = top
      flux_function = top_flux
    []
    # the top flux from a buffer instead (active = 'left right bottom top_buffer'); a buffer
    # value is the one its compute wrote at the start of the substep, at t
    [top_buffer]
      type = TensorNeumannBC
      variable = u
      boundary = top
      flux_buffer = top_flux
    []
  []
  [Solve]
    [top_flux]
      type = MooseFunctionTensor
      buffer = top_flux
      function = top_flux
    []
    [dudt]
      type = TimeDerivativeOperator
      buffer = dudt_u
      input = u
    []
    [lap]
      type = FiniteDifferenceLaplacian
      buffer = lap_u
      input = u
      factor = '${fparse -D}'
      stencil_width = ${stencil}
    []
  []
  [Postprocess]
    [exact_compute]
      type = MooseFunctionTensor
      buffer = exact
      function = u_exact
    []
    [diff_compute]
      type = ParsedCompute
      buffer = diff
      expression = 'abs(u - exact)'
      inputs = 'u exact'
    []
  []
[]

[TensorSolver]
  type = ImplicitFDSolver
  buffer = u
  operators = '${ops}'
  source = f
  linear_solver = TORCH_PCG
  l_tol = 1e-10
[]

[Postprocessors]
  [max_error]
    type = TensorExtremeValuePostprocessor
    buffer = diff
    value_type = MAX
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = ${num_steps}
  dt = ${dt}
[]

[Outputs]
  csv = true
[]

(test/tests/real_space/deep_ghost_faces.i)

# A stencil reaching four cells across a face (the 5-point biharmonic) with Neumann faces in x:
# its four ghost layers are the even mirror of the owned cells about the face. The result on
# 0 < x < 16 then equals the same stencil on the periodic domain 0 < x < 32 of the mirrored field
# (deep_ghost_periodic.i), which needs no ghost fill at a face, to round-off.
#
# u = exp(cos(pi x / 16)) sin(2 pi y / 8) is even about x = 0 and x = 16. With Dirichlet faces and
# u_ic = sin(pi x / 16) exp(cos(2 pi y / 8)), odd about both, the ghosts are the odd mirror.

u_ic = 'exp(cos(pi*x/16))*sin(2*pi*y/8)'

[Domain]
  dim = 2
  nx = 16
  ny = 8
  xmax = 16
  ymax = 8
  parallel_mode = REAL_SPACE
  periodic_directions = 'Y'
[]

[TensorBuffers]
  [u]
  []
  [bih]
  []
  [bih_sq]
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = ParsedCompute
      buffer = u
      extra_symbols = true
      expression = ${u_ic}
    []
  []
  [BCs]
    [left]
      type = TensorNeumannBC
      variable = u
      boundary = left
    []
    [right]
      type = TensorNeumannBC
      variable = u
      boundary = right
    []
  []
  [Postprocess]
    [bih]
      type = FiniteDifferenceBiharmonic
      buffer = bih
      input = u
      stencil_width = 5
    []
    [bih_sq]
      type = ParsedCompute
      buffer = bih_sq
      expression = 'bih^2'
      inputs = bih
    []
  []
[]

[Postprocessors]
  [integral_bih_sq]
    type = TensorIntegralPostprocessor
    buffer = bih_sq
  []
  [max_bih]
    type = TensorExtremeValuePostprocessor
    buffer = bih
    value_type = MAX
  []
  [min_bih]
    type = TensorExtremeValuePostprocessor
    buffer = bih
    value_type = MIN
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  csv = true
[]

(test/tests/real_space/bc_varying_laplacian.i)

# Boundary condition values that vary along the face, from functions and buffers.
#
# u = (x + 1) * y is harmonic and linear in the normal direction of every face, so the ghost
# values are exact, and the discrete Laplacian must be zero everywhere, including next to the
# faces. Each face takes its value from a different source.
[Domain]
  dim = 2
  nx = 20
  ny = 10
  parallel_mode = REAL_SPACE
  xmin = 0
  xmax = 1
  ymin = 0
  ymax = 1
[]

[Functions]
  [u_func]
    type = ParsedFunction
    expression = '(x + 1) * y'
  []
  [right_value]
    # u on x = 1
    type = ParsedFunction
    expression = '2 * y'
  []
  [top_flux]
    # du/dy on y = 1
    type = ParsedFunction
    expression = 'x + 1'
  []
  [bottom_flux]
    # -du/dy on y = 0 (outward normal -y)
    type = ParsedFunction
    expression = '-(x + 1)'
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = MooseFunctionTensor
      buffer = u
      function = u_func
    []
    # buffer values are face values: these depend on the tangential coordinate only
    [bottom_flux]
      type = MooseFunctionTensor
      buffer = bottom_flux
      function = bottom_flux
    []
  []
  [BCs]
    [left]
      # evaluated at the face position x = 0, where it is y
      type = TensorDirichletBC
      variable = u
      boundary = left
      value_function = u_func
    []
    [right]
      type = TensorDirichletBC
      variable = u
      boundary = right
      value_buffer = right_value
    []
    [bottom]
      type = TensorNeumannBC
      variable = u
      boundary = bottom
      flux_buffer = bottom_flux
    []
    [top]
      type = TensorNeumannBC
      variable = u
      boundary = top
      flux_function = top_flux
    []
  []
  [Solve]
    [lap_compute]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = lap
    []
    # listed after the Laplacian, whose ghost fill reads it: the dependency sort runs it first
    [right_value]
      type = MooseFunctionTensor
      buffer = right_value
      function = right_value
    []
  []
[]

[Postprocessors]
  [max_lap]
    type = TensorExtremeValuePostprocessor
    buffer = lap
    value_type = MAX
  []
  [min_lap]
    type = TensorExtremeValuePostprocessor
    buffer = lap
    value_type = MIN
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  [out]
    type = CSV
  []
[]

(test/tests/real_space/neumann_linear.i)

# Nonzero-flux Neumann boundary condition: steady 1D diffusion with u(0) = 1
# (Dirichlet, left) and du/dn = 2 (Neumann, right) has the exact solution
# u = 1 + 2*x. Y is periodic, and the IC is not the steady profile.
[Domain]
  dim = 2
  nx = 20
  ny = 8
  parallel_mode = REAL_SPACE
  periodic_directions = 'Y'
  xmin = 0
  xmax = 1
  ymin = -1
  ymax = 1
[]

[Functions]
  [u_ic_func]
    type = ParsedFunction
    expression = '0.5'
  []
  [u_exact_func]
    type = ParsedFunction
    expression = '1 + 2 * x'
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = MooseFunctionTensor
      buffer = u
      function = u_ic_func
    []
  []
  [BCs]
    [left]
      type = TensorDirichletBC
      variable = u
      boundary = left
      value = 1
    []
    [right]
      type = TensorNeumannBC
      variable = u
      boundary = right
      flux = 2
    []
  []
  [Solve]
    [dt]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = dudt
    []
    [u_exact]
      type = MooseFunctionTensor
      buffer = u_exact
      function = u_exact_func
    []
    [diff]
      type = ParsedCompute
      buffer = diff
      expression = 'abs(u - u_exact)'
      inputs = 'u u_exact'
    []
  []
[]

[TensorSolver]
  type = RealSpaceForwardEuler
  buffer = u
  time_derivative = dudt
  substeps = 1000
[]

[Postprocessors]
  [max_error]
    type = TensorExtremeValuePostprocessor
    buffer = diff
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
[]

[Executioner]
  type = Transient
  # same grid and CFL margin as dirichlet_linear.i; the Neumann face makes the slowest
  # mode decay more slowly, so max_error needs 15 steps to plateau
  dt = 1
  num_steps = 15
[]

[Outputs]
  [out]
    type = CSV
  []
[]

(test/tests/real_space/neumann_conservation.i)

# Zero-flux Neumann boundary condition: pure diffusion with zero flux on the X faces
# and periodic Y, from a non-uniform initial condition. The total integral of u must
# be conserved to near machine precision while u relaxes to its mean.
[Domain]
  dim = 2
  nx = 20
  ny = 8
  parallel_mode = REAL_SPACE
  periodic_directions = 'Y'
  xmin = 0
  xmax = 1
  ymin = -1
  ymax = 1
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = ParsedCompute
      buffer = u
      # non-uniform in x and y, so diffusion moves mass internally
      expression = '1 + sin(2 * pi * x) + 0.3 * cos(pi * y)'
      extra_symbols = true
    []
  []
  [BCs]
    [left]
      type = TensorNeumannBC
      variable = u
      boundary = left
      flux = 0
    []
    [right]
      type = TensorNeumannBC
      variable = u
      boundary = right
      flux = 0
    []
  []
  [Solve]
    [dt]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = dudt
    []
  []
[]

[TensorSolver]
  type = RealSpaceForwardEuler
  buffer = u
  time_derivative = dudt
  substeps = 1000
[]

[Postprocessors]
  [mass]
    type = TensorIntegralPostprocessor
    buffer = u
    execute_on = 'INITIAL TIMESTEP_END'
  []
[]

[Executioner]
  type = Transient
  # same grid and CFL margin as dirichlet_linear.i
  dt = 1
  num_steps = 4
[]

[Outputs]
  [out]
    type = CSV
  []
[]

(test/tests/real_space/dirichlet_2d_corners.i)

# Non-periodic on both axes (Dirichlet left/right, zero-flux Neumann bottom/top),
# so the ghost fill reaches the four domain corners. exchangeGhostLayers() fills one
# axis at a time, so a corner ghost depends on the fill order.
#
# u = 1 + 2*x is uniform on every face, so it satisfies all four BCs exactly, and the
# discrete Laplacian must be zero everywhere, including the corner-adjacent cells.
[Domain]
  dim = 2
  nx = 20
  ny = 10
  parallel_mode = REAL_SPACE
  xmin = 0
  xmax = 1
  ymin = 0
  ymax = 1
[]

[Functions]
  [u_func]
    type = ParsedFunction
    expression = '1 + 2 * x'
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      # the steady profile implied by the four BCs below
      type = MooseFunctionTensor
      buffer = u
      function = u_func
    []
  []
  [BCs]
    [left]
      type = TensorDirichletBC
      variable = u
      boundary = left
      value = 1
    []
    [right]
      type = TensorDirichletBC
      variable = u
      boundary = right
      value = 3
    []
    [bottom]
      type = TensorNeumannBC
      variable = u
      boundary = bottom
      flux = 0
    []
    [top]
      type = TensorNeumannBC
      variable = u
      boundary = top
      flux = 0
    []
  []
  [Solve]
    [lap_compute]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = lap
    []
  []
[]

[Postprocessors]
  [max_lap]
    type = TensorExtremeValuePostprocessor
    buffer = lap
    value_type = MAX
  []
  [min_lap]
    type = TensorExtremeValuePostprocessor
    buffer = lap
    value_type = MIN
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  [out]
    type = CSV
  []
[]

Overview
Example Input File Syntax
Input Parameters
Input Files