FVBCs System

For an overview of MOOSE FV please see Finite Volume Design Decisions in MOOSE.

The finite volume method (FVM) distinguishes between two types of boundary conditions.

* FVDirichletBC prescribes values of the FVM variables on the boundary. This boundary condition acts similarly to Dirichlet boundary conditions in FEM but it is implemented using a ghost element method.

* FVFluxBC prescribes the flux on a boundary. This boundary condition is similar to integrated boundary conditions in FEM.

Currently, the FVDirichletBC category only contains a single class that applies a fixed value on the boundary. In the future, more specialized classes will be added.

FVBCs block

FVM boundary conditions are added to simulation input files in the FVBCs as in the example below.

Listing 1: Example of the FVBCs block in a MOOSE input file.

[FVBCs]
  [left]
    type = FVNeumannBC
    variable = v
    boundary = left
    value = 5
  []
  [right]
    type = FVDirichletBC
    variable = v
    boundary = right
    value = 42
  []
[]

In this example input, a diffusion equation with flux boundary conditions on the left and Dirichlet boundary conditions on the right is solved. To understand the differences between these two boundary conditions, let's start with the diffusion equation:

$var element = document.getElementById("moose-equation-b6393321-f78e-4e64-b9a2-52d81560d5c8");katex.render(" - \\nabla \\cdot D \\nabla v = 0.", element, {displayMode:true,throwOnError:false});$

and the boundary conditions on the left:

$var element = document.getElementById("moose-equation-ebb1ce24-827f-4235-ab83-a3b1a96b25d3");katex.render(" - D \\nabla v \\cdot \\vec{n}= 5,", element, {displayMode:true,throwOnError:false});$

where $var element = document.getElementById("moose-equation-7513286d-8a53-4d24-a011-e0f497bdf419");katex.render("\\vec{n}", element, {displayMode:false,throwOnError:false});$ is the outward normal and on the right:

$var element = document.getElementById("moose-equation-1a4d3005-46a7-47fa-99b2-5976b07ca511");katex.render(" v = 42.", element, {displayMode:true,throwOnError:false});$

For seeing how the flux boundary condition is applied, the diffusion equation is integrated over the extent of an element adjacent to the left boundary and Gauss' theorem is applied to the divergence:

$var element = document.getElementById("moose-equation-cf46db83-366e-4ceb-8349-2ccd52129829");katex.render(" -\\int_{\\Omega} \\nabla \\cdot D \\nabla v dV = -\\int_{\\partial \\Omega_l} D \\nabla v \\cdot \\vec{n} dA -\\int_{\\partial \\Omega \\setminus \\partial \\Omega_l} D \\nabla v \\cdot \\vec{n} dA = 5 A_{\\partial \\Omega_l} -\\int_{\\partial \\Omega \\setminus \\partial \\Omega_l} D \\nabla v \\cdot \\vec{n} dA=0,", element, {displayMode:true,throwOnError:false});$

where $var element = document.getElementById("moose-equation-c8b3b628-6d58-4dab-8056-3db359b8d391");katex.render("\\Omega", element, {displayMode:false,throwOnError:false});$ is the element volume, $var element = document.getElementById("moose-equation-fc958820-855e-45e3-aff9-a47c2b454e28");katex.render("\\partial \\Omega_l", element, {displayMode:false,throwOnError:false});$ are all faces that belong to the left sideset, $var element = document.getElementById("moose-equation-fd751daf-63b4-4a36-94d4-123fc73f3cec");katex.render("\\partial \\Omega", element, {displayMode:false,throwOnError:false});$ are all faces, and $var element = document.getElementById("moose-equation-6bb9f4c3-7eff-4874-8ae9-0f331e374970");katex.render("A_{\\partial \\Omega_l}", element, {displayMode:false,throwOnError:false});$ is the area of face. Flux boundary conditions are applied by replacing appropriate terms in the FVM balance by the value of the flux prescribed on the boundary.

Dirichlet boundary conditions are applied differently. Let us first write a balance equation for an element that is adjacent to the right boundary:

$var element = document.getElementById("moose-equation-d7b1ad49-d5d9-4834-8fe1-afcd38691d74");katex.render(" -\\int_{\\partial \\Omega_r} D \\nabla v \\cdot \\vec{n} dA -\\int_{\\partial \\Omega \\setminus \\partial \\Omega_r} D \\nabla v \\cdot \\vec{n} dA =0,", element, {displayMode:true,throwOnError:false});$

MOOSE uses the ghost element method to apply Dirichlet boundary conditions for FVM. The process of using a ghost elements is the following:

Place a virtual element across the Dirichlet boundary.
Compute the value of $var element = document.getElementById("moose-equation-4e570f8f-c712-4cce-a9e6-c28d290c7ae1");katex.render("v", element, {displayMode:false,throwOnError:false});$ in the ghost element as the extrapolation of the element value and the desired value on the boundary.
Assign the value of $var element = document.getElementById("moose-equation-ae5b871c-4771-412f-8aa1-e87bb3357e92");katex.render("v", element, {displayMode:false,throwOnError:false});$ in the ghost element.
Evaluate the numerical fluxes as if you were on an interior face.

For implementing the ghost element method an extrapolation must be selected. Currently, MOOSE FVM only supports linear extrapolation. If the value of the Dirichlet boundary condition is denoted by $var element = document.getElementById("moose-equation-3d612dbd-a5f7-43c2-8dbf-e3b8b8a0a4fc");katex.render("v_D", element, {displayMode:false,throwOnError:false});$ and the value in the element is denoted by $var element = document.getElementById("moose-equation-b0158a10-d94f-4c60-9108-e3c2112bb10b");katex.render("v_E", element, {displayMode:false,throwOnError:false});$ , then the ghost element value $var element = document.getElementById("moose-equation-3407e8ad-3abc-4c3e-b376-3b437d4b3680");katex.render("v_G", element, {displayMode:false,throwOnError:false});$ is:

$var element = document.getElementById("moose-equation-d4d6983a-06b6-4b46-9944-3e34fe645739");katex.render(" v_G = 2 v_D - v_E.", element, {displayMode:true,throwOnError:false});$

The parameters available in boundary conditions are equivalent to FEM boundary conditions and are not discussed in detail here.

FVBCs source code: FVDirichletBC

FVDirichletBC objects assigns a constant value on a boundary. Implementation of a FVM Dirichlet boundary condition usually only requires overriding the boundaryValue method. The boundaryValue method must return the value of the variable on the Dirichlet boundary.

Listing 2: Example source code for FVDirichletBC.

#include "FVDirichletBC.h"

registerMooseObject("MooseApp", FVDirichletBC);

InputParameters
FVDirichletBC::validParams()
{
  InputParameters params = FVDirichletBCBase::validParams();
  params.addClassDescription("Defines a Dirichlet boundary condition for finite volume method.");
  params.addRequiredParam<Real>("value", "value to enforce at the boundary face");
  return params;
}

FVDirichletBC::FVDirichletBC(const InputParameters & parameters)
  : FVDirichletBCBase(parameters), _val(getParam<Real>("value"))
{
}

ADReal
FVDirichletBC::boundaryValue(const FaceInfo & /*fi*/) const
{
  return _val;
}

FVBCs source code: FVFluxBC

FVNeumannBC objects assign a constant flux on a boundary. Implementation of a flux boundary condition usually only requires overriding the computeQpResidual() method. FVNeumannBC reads a constant value from the parameters and then returns it in computeQpResidual().

Listing 3: Example source code for FVNeumannBC.

#include "FVNeumannBC.h"

registerMooseObject("MooseApp", FVNeumannBC);

InputParameters
FVNeumannBC::validParams()
{
  InputParameters params = FVFluxBC::validParams();
  params.addClassDescription("Neumann boundary condition for finite volume method.");
  params.addParam<Real>("value", 0.0, "The value of the flux crossing the boundary.");
  return params;
}

FVNeumannBC::FVNeumannBC(const InputParameters & parameters)
  : FVFluxBC(parameters), _value(getParam<Real>("value"))
{
}

ADReal
FVNeumannBC::computeQpResidual()
{
  return -_value;
}

FVBCs source code: FVBurgersOutflowBC

Flux boundary conditions can be more complicated than assigning a constant value. In this example, the outflow contribution for the Burgers' equation is computed. The relevant term is (note 1D):

$var element = document.getElementById("moose-equation-6985085f-9ab0-4880-b6ab-29b8dcc3cdd5");katex.render("\\frac{1}{2} \\int \\frac{\\partial}{\\partial x}v^2 dx = \\frac{1}{2} \\left(v^2_R n_R + v^2_L n_L\\right),", element, {displayMode:true,throwOnError:false});$

where $var element = document.getElementById("moose-equation-131dbd64-b398-47b7-8b04-c9cca431c8ac");katex.render("v_R", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-e45e40fe-cbd8-4a2a-aeec-03d58ad22384");katex.render("v_L", element, {displayMode:false,throwOnError:false});$ are the values of $var element = document.getElementById("moose-equation-dfd1081c-85fc-4e51-b5bb-21d6458012dd");katex.render("v", element, {displayMode:false,throwOnError:false});$ on the left and right boundaries of the element and $var element = document.getElementById("moose-equation-c5990eb3-4613-44b8-975d-94f340e5b424");katex.render("n_R", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-c4341d33-8a23-4cd2-b857-39d64cb83eb4");katex.render("n_L", element, {displayMode:false,throwOnError:false});$ are the outward normals on these faces. Let's assume that the left side is a boundary face where the FVBurgersOutflowBC is applied. On that boundary we have $var element = document.getElementById("moose-equation-03e511b8-ea53-46e5-95b3-efc4a0c0f6f7");katex.render("n_L = -1", element, {displayMode:false,throwOnError:false});$ . The FVBurgersOutflowBC boundary condition uses upwinding, i.e. it uses the element value $var element = document.getElementById("moose-equation-84733da8-b6ba-4131-b2f3-9589c49cb4fb");katex.render("v", element, {displayMode:false,throwOnError:false});$ as boundary values on outflow faces.

The code listed below first checks if the left is actually an outflow side by using the cell value of the $var element = document.getElementById("moose-equation-035aa771-5d5e-4c73-900a-a34641e0ce19");katex.render("v", element, {displayMode:false,throwOnError:false});$ (element average, upwinding!) and dotting it with the normal. If $var element = document.getElementById("moose-equation-0df6831f-4734-48d7-8f79-30b811ee1d53");katex.render("v n_L > 0", element, {displayMode:false,throwOnError:false});$ , then the left is an outflow side. In this case the contribution $var element = document.getElementById("moose-equation-4fe1821b-b0da-4595-8157-4928086f7439");katex.render("1/2 v^2 n_L", element, {displayMode:false,throwOnError:false});$ is added, otherwise no contribution is added.

Listing 4: Outflow boundary condition for the Burgers' equation.

FVBurgersOutflowBC::computeQpResidual()
{
  mooseAssert(_face_info->elem().dim() == 1, "FVBurgersOutflowBC works only in 1D");

  ADReal r = 0;
  // only add this on outflow faces
  if (_u[_qp] * _normal(0) > 0)
    r = 0.5 * _u[_qp] * _u[_qp] * _normal(0);
  return r;
}

In this case, the boundary condition does not represent a fixed inflow, but rather a free outflow condition.

Available Objects

Moose App
FVADFunctorDirichletBCUses the value of a functor to set a Dirichlet boundary value.
FVBoundaryIntegralValueConstraintThis class is used to enforce integral of phi = boundary area * phi_0 with a Lagrange multiplier approach.
FVConstantScalarOutflowBCConstant velocity scalar advection boundary conditions for finite volume method.
FVDirichletBCDefines a Dirichlet boundary condition for finite volume method.
FVFunctionDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-bdca8a79-11fc-4f66-b359-3bef0ecb840e");katex.render("u=g(t,\\vec{x})", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-20bd6617-71d7-42d0-8aff-729e5956586d");katex.render("g", element, {displayMode:false,throwOnError:false});$ is a (possibly) time and space-dependent MOOSE Function.
FVFunctionNeumannBCNeumann boundary condition for finite volume method.
FVFunctorDirichletBCUses the value of a functor to set a Dirichlet boundary value.
FVFunctorNeumannBCNeumann boundary condition for the finite volume method.
FVNeumannBCNeumann boundary condition for finite volume method.
FVOrthogonalBoundaryDiffusionImposes an orthogonal diffusion boundary term with specified boundary function.
FVPostprocessorDirichletBCDefines a Dirichlet boundary condition for finite volume method.

(moose/test/tests/fvkernels/fv_simple_diffusion/neumann.i)

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

[Variables]
  [u]
  []
  [v]
    family = MONOMIAL
    order = CONSTANT
    fv = true
  []
[]

[Kernels]
  [diff]
    type = ADDiffusion
    variable = u
  []
[]

[FVKernels]
  [diff]
    type = FVDiffusion
    variable = v
    coeff = coeff
  []
[]

[FVBCs]
  [left]
    type = FVNeumannBC
    variable = v
    boundary = left
    value = 5
  []
  [right]
    type = FVDirichletBC
    variable = v
    boundary = right
    value = 42
  []
[]

[Materials]
  [diff]
    type = ADGenericFunctorMaterial
    prop_names = 'coeff'
    prop_values = '1'
  []
[]

[BCs]
  [left]
    type = ADNeumannBC
    variable = u
    boundary = left
    value = 5
  []
  [right]
    type = ADDirichletBC
    variable = u
    boundary = right
    value = 42
  []
[]

[Executioner]
  type = Steady
  solve_type = 'PJFNK'
  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'
[]

[Outputs]
  exodus = true
[]

(moose/framework/src/fvbcs/FVDirichletBC.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FVDirichletBC.h"

registerMooseObject("MooseApp", FVDirichletBC);

InputParameters
FVDirichletBC::validParams()
{
  InputParameters params = FVDirichletBCBase::validParams();
  params.addClassDescription("Defines a Dirichlet boundary condition for finite volume method.");
  params.addRequiredParam<Real>("value", "value to enforce at the boundary face");
  return params;
}

FVDirichletBC::FVDirichletBC(const InputParameters & parameters)
  : FVDirichletBCBase(parameters), _val(getParam<Real>("value"))
{
}

ADReal
FVDirichletBC::boundaryValue(const FaceInfo & /*fi*/) const
{
  return _val;
}

(moose/framework/src/fvbcs/FVNeumannBC.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FVNeumannBC.h"

registerMooseObject("MooseApp", FVNeumannBC);

InputParameters
FVNeumannBC::validParams()
{
  InputParameters params = FVFluxBC::validParams();
  params.addClassDescription("Neumann boundary condition for finite volume method.");
  params.addParam<Real>("value", 0.0, "The value of the flux crossing the boundary.");
  return params;
}

FVNeumannBC::FVNeumannBC(const InputParameters & parameters)
  : FVFluxBC(parameters), _value(getParam<Real>("value"))
{
}

ADReal
FVNeumannBC::computeQpResidual()
{
  return -_value;
}

(moose/test/src/fvbcs/FVBurgersOutflowBC.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FVBurgersOutflowBC.h"

registerMooseObject("MooseTestApp", FVBurgersOutflowBC);

InputParameters
FVBurgersOutflowBC::validParams()
{
  InputParameters params = FVFluxBC::validParams();
  return params;
}

FVBurgersOutflowBC::FVBurgersOutflowBC(const InputParameters & parameters) : FVFluxBC(parameters) {}

ADReal
FVBurgersOutflowBC::computeQpResidual()
{
  mooseAssert(_face_info->elem().dim() == 1, "FVBurgersOutflowBC works only in 1D");

  ADReal r = 0;
  // only add this on outflow faces
  if (_u[_qp] * _normal(0) > 0)
    r = 0.5 * _u[_qp] * _u[_qp] * _normal(0);
  return r;
}

FVBCs block
FVBCs source code : FVDirichletBC
FVBCs source code : FVFluxBC
FVBCs source code : FVBurgersOutflowBC
Available Objects