BCs System

The BCs system is used to impose boundary conditions in a finite element problem. Each BC object sets the boundary condition for a single variable/equation, though multiple boundaries may be specified at once.

note

See FVBCs for boundary conditions of finite volume problems.

Some of the main types of boundary conditions are: - Dirichlet Boundary conditions to set the value of a variable on a boundary - Neumann Boundary conditions to set a flux for the equation corresponding to the variable. Depending on the equation being solved, this can be equivalent to setting the value of the derivative of the variable on the boundary - Robin boundary conditions to solve an equation tying both the variable value and its derivatives on the boundary

In MOOSE, boundary conditions are split in two categories: NodalBCs and IntegratedBCs. Similar to kernels, computeQpResidual/Jacobian are the main routine to implement for most boundary conditions. Automatic differentiation is implemented for boundary conditions. AD BCs do not require implementing computeQpJacobian.

Nodal boundary conditions

Nodal boundary conditions are applied on nodes in the mesh. Nodal boundary conditions may only be applied on variables that have degrees of freedom at nodes, such as Lagrange variables.

We show below code snippets for the DirichletBCBase. This boundary condition sets the value of a variable on a node.

If the value is preset, the computeQpValue is called instead of the computeQpResidual. This value is then directly placed in the solution vector.

  params.addRequiredParam<Real>("value", "Value of the BC");
  params.declareControllable("value");
  params.addClassDescription("Imposes the essential boundary condition $u=g$, where $g$ "
                             "is a constant, controllable value.");
  return params;
}

If the value is not preset, the computeQpResidual routine is called. The residual of a non-preset DirichletBC is simply the difference between the desired value and the current variable value.

Real
DirichletBCBase::computeQpResidual()
{
  return _u[_qp] - computeQpValue();
}

note

_qp, the index over quadrature points, is simply 0 on nodes. We use this indexing in order to keep consistent user interfaces.

Integrated boundary conditions

Integrated boundary conditions are applied on sides in the mesh. A local quadrature-based integration is performed to compute the residual and Jacobian contribution of the boundary condition.

In the following snippet, we show the definition of the contribution to the residual of a FunctionNeumannBC. The computeQpResidual simply returns the value of the flux.

Real
FunctionNeumannBC::computeQpResidual()
{
  return -_test[_i][_qp] * _func.value(_t, _q_point[_qp]);
}

Available Objects

Moose App
ADConservativeAdvectionBCBoundary condition for advection when it is integrated by parts. Supports Dirichlet (inlet-like) and implicit (outlet-like) conditions.
ADDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-b711b83b-036e-4c13-abd3-afbd8af3b542");katex.render("u=g", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-e1c7a682-c7aa-4fb0-b09c-60b9c244789d");katex.render("g", element, {displayMode:false,throwOnError:false});$ is a constant, controllable value.
ADFunctionDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-2e4147e0-e5dd-418c-8548-d9585adda685");katex.render("u=g", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-9d284b2f-8d20-4b33-bbb6-a836de54e03d");katex.render("g", element, {displayMode:false,throwOnError:false});$ is calculated by a function.
ADFunctionNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-5009f565-63ab-4bf9-aa99-6b511fb38e85");katex.render("\\frac{\\partial u}{\\partial n}=h(t,\\vec{x})", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-7f737e27-1e36-4cca-bb24-74d2c82808e6");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a (possibly) time and space-dependent MOOSE Function.
ADFunctionPenaltyDirichletBCEnforces a (possibly) time and space-dependent MOOSE Function Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
ADMatNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-0b69a342-e1b9-4ff4-9778-ea03793d01c0");katex.render("\\frac{C \\partial u}{\\partial n}=M*h", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-77673314-5439-486b-91aa-2655a459c8c0");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a constant, $var element = document.getElementById("moose-equation-cd22536b-f189-4030-b184-3c03bb535575");katex.render("M", element, {displayMode:false,throwOnError:false});$ is a material property, and $var element = document.getElementById("moose-equation-f799c71b-67a2-4e47-a215-94c776bc2a9d");katex.render("C", element, {displayMode:false,throwOnError:false});$ is a coefficient defined by the kernel for $var element = document.getElementById("moose-equation-cef783e5-0f79-4c31-ab1b-f1860a81baff");katex.render("u", element, {displayMode:false,throwOnError:false});$ .
ADMatchedValueBCImplements a NodalBC which equates two different Variables' values on a specified boundary.
ADNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-a213e783-587a-470c-9493-5c15f0dc5bfd");katex.render("\\frac{\\partial u}{\\partial n}=h", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-238c478d-4d47-4053-9c55-5a7482471d06");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a constant, controllable value.
ADPenaltyDirichletBCEnforces a Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
ADVectorFunctionDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-aac4f098-cd12-4932-a4c8-ddfc06f9fa35");katex.render("\\vec{u}=\\vec{g}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-6be84b85-0150-430c-8d05-c9cb7bee0429");katex.render("\\vec{g}", element, {displayMode:false,throwOnError:false});$ components are calculated with functions.
ADVectorFunctionNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-acf22392-b277-4d25-b0c3-1dcc4f571577");katex.render("\\frac{\\partial \\vec{u}}{\\partial n} = \\vec{h}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-7b4679a1-9a4d-4872-b274-7f5b8ac16f99");katex.render("\\vec{h}", element, {displayMode:false,throwOnError:false});$ is a (possibly) time and space-dependent MOOSE Function.
ADVectorMatchedValueBCImplements a ADVectorNodalBC which equates two different Variables' values on a specified boundary.
ArrayDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-dd183553-0efe-42a2-9dbc-b70be640ecce");katex.render("\\vec{u}=\\vec{g}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-a949a2e2-144c-47d0-a5bf-de30cd3bdcc1");katex.render("\\vec{g}", element, {displayMode:false,throwOnError:false});$ are constant, controllable values.
ArrayHFEMDirichletBCImposes the Dirichlet BC with HFEM.
ArrayNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-70869143-4d81-41b2-b749-1b45e8514973");katex.render("\\frac{\\partial u}{\\partial n}=h", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-0304f3b5-022e-47c5-9a87-4b2a1a616947");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a constant, controllable value.
ArrayPenaltyDirichletBCEnforces a Dirichlet boundary condition in a weak sense with $var element = document.getElementById("moose-equation-7c92f8ed-69e5-4b27-b869-d0a9c962e7e9");katex.render("p(\\vec{u}^\\ast, \\vec{u} - \\vec{u}_0)", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-49bed1d1-c8d1-461f-b5cc-3e8ae6f8c435");katex.render("p", element, {displayMode:false,throwOnError:false});$ is the constant scalar penalty; $var element = document.getElementById("moose-equation-8a4bc6ef-494e-4780-838c-e88661b4e786");katex.render("\\vec{u}^\\ast", element, {displayMode:false,throwOnError:false});$ is the test functions and $var element = document.getElementById("moose-equation-c054a9ad-680d-47e3-beda-ffa6560d46e5");katex.render("\\vec{u} - \\vec{u}_0", element, {displayMode:false,throwOnError:false});$ is the differences between the current solution and the Dirichlet data.
ArrayVacuumBCImposes the Robin boundary condition $var element = document.getElementById("moose-equation-1593a59f-b7ec-437e-9f88-4c78b790fd79");katex.render("\\partial_n \\vec{u}=-\\frac{\\vec{\\alpha}}{2}\\vec{u}", element, {displayMode:false,throwOnError:false});$ .
ConvectiveFluxBCDetermines boundary values via the initial and final values, flux, and exposure duration
CoupledVarNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-2068607f-48ce-4165-a7a3-bf6a4cc5f85f");katex.render("\\frac{\\partial u}{\\partial n}=v", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-fea3244c-1b48-4437-be38-566061a3b5a3");katex.render("v", element, {displayMode:false,throwOnError:false});$ is a variable.
DGFunctionDiffusionDirichletBCDiffusion Dirichlet boundary condition for discontinuous Galerkin method.
DiffusionFluxBCComputes a boundary residual contribution consistent with the Diffusion Kernel. Does not impose a boundary condition; instead computes the boundary contribution corresponding to the current value of grad(u) and accumulates it in the residual vector.
DirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-d3aef542-b09f-4d3b-8f4b-c5fa104cfcc5");katex.render("u=g", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-ea9587e6-bfe7-4de7-8b1c-6e55fd897a9c");katex.render("g", element, {displayMode:false,throwOnError:false});$ is a constant, controllable value.
EigenArrayDirichletBCArray Dirichlet BC for eigenvalue solvers
EigenDirichletBCDirichlet BC for eigenvalue solvers
FunctionDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-945b0989-1ca5-4a5c-9e83-0faa1c9dfb92");katex.render("u=g(t,\\vec{x})", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-cf6e81aa-6ab1-4539-bedf-7422e70cb59a");katex.render("g", element, {displayMode:false,throwOnError:false});$ is a (possibly) time and space-dependent MOOSE Function.
FunctionGradientNeumannBCImposes the integrated boundary condition arising from integration by parts of a diffusion/heat conduction operator, and where the exact solution can be specified.
FunctionNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-932d28f7-fe5d-4c77-8dcc-ba36118332d5");katex.render("\\frac{\\partial u}{\\partial n}=h(t,\\vec{x})", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-cc343bd9-de1f-4a5e-a42e-63410764615f");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a (possibly) time and space-dependent MOOSE Function.
FunctionPenaltyDirichletBCEnforces a (possibly) time and space-dependent MOOSE Function Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
FunctorNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-0d05908b-0d53-451a-ab9f-13708113239d");katex.render("\\frac{\\partial u}{\\partial n}=h(t,\\vec{x})", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-7439d059-ec63-405c-9b05-1fda16371f86");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a functor.
HFEMDirichletBCImposes the Dirichlet BC with HFEM.
LagrangeVecDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-18595689-21a4-4818-8da8-62006074b153");katex.render("\\vec{u}=\\vec{g}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-44b6e5e2-96e4-42fc-999b-a8e272308d0f");katex.render("\\vec{g}", element, {displayMode:false,throwOnError:false});$ are constant, controllable values.
LagrangeVecFunctionDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-8cc9f3b8-fe0f-4613-8116-8ad856f859f0");katex.render("\\vec{u}=\\vec{g}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-00a74421-5f54-414a-a159-cd122353f254");katex.render("\\vec{g}", element, {displayMode:false,throwOnError:false});$ components are calculated with functions.
MatNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-abfda22a-e061-4f58-a205-da9ac865849d");katex.render("\\frac{C \\partial u}{\\partial n}=M*h", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-3078e63b-15b6-4d39-8dd7-05b7ae073ddc");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a constant, $var element = document.getElementById("moose-equation-6c490d4c-e8e4-4b75-a0c4-4a5d3e4533b9");katex.render("M", element, {displayMode:false,throwOnError:false});$ is a material property, and $var element = document.getElementById("moose-equation-a6f2e31c-614d-4d2d-a9f2-80c5d468a15d");katex.render("C", element, {displayMode:false,throwOnError:false});$ is a coefficient defined by the kernel for $var element = document.getElementById("moose-equation-4f329ecb-f667-4e2e-881e-80a88eeaddc4");katex.render("u", element, {displayMode:false,throwOnError:false});$ .
MatchedValueBCImplements a NodalBC which equates two different Variables' values on a specified boundary.
NeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-79a0263c-71b4-450f-977b-b8d85b7b313c");katex.render("\\frac{\\partial u}{\\partial n}=h", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-ec303919-fe4f-4650-8431-baa79b618b30");katex.render("h", element, {displayMode:false,throwOnError:false});$ is a constant, controllable value.
OneDEqualValueConstraintBCComputes the integral of lambda times dg term from the mortar method (for two 1D domains only).
PenaltyDirichletBCEnforces a Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
PostprocessorDirichletBCDirichlet boundary condition with value prescribed by a Postprocessor value.
PostprocessorNeumannBCNeumann boundary condition with value prescribed by a Postprocessor value.
SinDirichletBCImposes a time-varying essential boundary condition $var element = document.getElementById("moose-equation-bde388b8-6f03-4c6f-aafc-fcfb5efb6f6e");katex.render("u=g(t)", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-f93c818f-db18-44c8-ab24-3eddd2cc8b99");katex.render("g(t)", element, {displayMode:false,throwOnError:false});$ varies from an given initial value at time $var element = document.getElementById("moose-equation-16974ed9-0276-4b00-8499-924f51bb6ef2");katex.render("t=0", element, {displayMode:false,throwOnError:false});$ to a given final value over a specified duration.
SinNeumannBCImposes a time-varying flux boundary condition $var element = document.getElementById("moose-equation-17f6f75b-0a40-4540-be34-4d1244bc2c02");katex.render("\\frac{\\partial u}{\\partial n}=g(t)", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-b1249a4b-a699-475c-943e-12de6bfe2e76");katex.render("g(t)", element, {displayMode:false,throwOnError:false});$ varies from an given initial value at time $var element = document.getElementById("moose-equation-10e988bb-ea00-4284-88e5-3b2c5028b4d9");katex.render("t=0", element, {displayMode:false,throwOnError:false});$ to a given final value over a specified duration.
VacuumBCVacuum boundary condition for diffusion.
VectorCurlPenaltyDirichletBCEnforces a Dirichlet boundary condition for the curl of vector nonlinear variables in a weak sense by applying a penalty to the difference in the current solution and the Dirichlet data.
VectorDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-d8ff4472-e064-45c0-b84e-d51aed43f167");katex.render("\\vec{u}=\\vec{g}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-f7e2f7a9-a8da-4adb-bd46-4dc96989413d");katex.render("\\vec{g}", element, {displayMode:false,throwOnError:false});$ are constant, controllable values.
VectorFunctionDirichletBCImposes the essential boundary condition $var element = document.getElementById("moose-equation-911df57e-c182-4b59-912b-89793895c5bd");katex.render("\\vec{u}=\\vec{g}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-f131b310-fddd-43f5-9ff9-0eef3e3a1273");katex.render("\\vec{g}", element, {displayMode:false,throwOnError:false});$ components are calculated with functions.
VectorNeumannBCImposes the integrated boundary condition $var element = document.getElementById("moose-equation-ba1e1bf6-3b5c-4d43-bf6c-0b6951ba61d1");katex.render("\\frac{\\partial u}{\\partial n}=\\vec{V}\\cdot\\hat{n}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-db5e1b2d-c710-423e-80e2-59bd10716bf9");katex.render("\\vec{V}", element, {displayMode:false,throwOnError:false});$ is a user-defined, constant vector.
VectorPenaltyDirichletBCEnforces a Dirichlet boundary condition for vector nonlinear variables in a weak sense by applying a penalty to the difference in the current solution and the Dirichlet data.
WeakGradientBCComputes a boundary residual contribution consistent with the Diffusion Kernel. Does not impose a boundary condition; instead computes the boundary contribution corresponding to the current value of grad(u) and accumulates it in the residual vector.
Tensor Mechanics App
ADPenaltyInclinedNoDisplacementBCPenalty Enforcement of an inclined boundary condition
ADPressureApplies a pressure on a given boundary in a given direction
ADTorqueApply a moment as tractions distributed over a surface around a pivot point. This should operate on the displaced mesh for large deformations.
CoupledPressureBCApplies a pressure from a variable on a given boundary in a given direction
DashpotBC
DisplacementAboutAxisImplements a boundary condition that enforces rotationaldisplacement around an axis on a boundary
InteractionIntegralBenchmarkBCImplements a boundary condition that enforces a displacement field around a crack tip based on applied stress intensity factors.
PenaltyInclinedNoDisplacementBCPenalty Enforcement of an inclined boundary condition
PresetAccelerationPrescribe acceleration on a given boundary in a given direction
PresetDisplacementPrescribe the displacement on a given boundary in a given direction.
PresetVelocity
PressureApplies a pressure on a given boundary in a given direction
StickyBCImposes the boundary condition $var element = document.getElementById("moose-equation-2918fbdb-84a6-4b07-a07d-dc37af051a47");katex.render("u = u_{old}", element, {displayMode:false,throwOnError:false});$ if $var element = document.getElementById("moose-equation-05df254a-c6c5-4bb8-b820-914b50c387c9");katex.render("u_{old}", element, {displayMode:false,throwOnError:false});$ exceeds the bounds provided
TorqueApply a moment as tractions distributed over a surface around a pivot point. This should operate on the displaced mesh for large deformations.
Chamois App
FiniteStrainPressureApplies a pressure on a given boundary in a given direction
FunctionDirichletIncrementalBCImposes a FunctionDirichletBC with possibility of an offset, which can be set to the current boundary value at discrete points in time

Available Subsystems

Available Actions

Moose App
AddBCActionAdd a BoundaryCondition object to the simulation.

(moose/framework/src/bcs/DirichletBC.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 "DirichletBC.h"

registerMooseObject("MooseApp", DirichletBC);

InputParameters
DirichletBC::validParams()
{
  InputParameters params = DirichletBCBase::validParams();
  params.addRequiredParam<Real>("value", "Value of the BC");
  params.declareControllable("value");
  params.addClassDescription("Imposes the essential boundary condition $u=g$, where $g$ "
                             "is a constant, controllable value.");
  return params;
}

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

Real
DirichletBC::computeQpValue()
{
  return _value;
}

(moose/framework/src/bcs/DirichletBCBase.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 "DirichletBCBase.h"

InputParameters
DirichletBCBase::validParams()
{
  InputParameters params = NodalBC::validParams();
  params.addParam<bool>(
      "preset", true, "Whether or not to preset the BC (apply the value before the solve begins).");
  return params;
}

DirichletBCBase::DirichletBCBase(const InputParameters & parameters)
  : NodalBC(parameters), _preset(getParam<bool>("preset"))
{
}

void
DirichletBCBase::computeValue(NumericVector<Number> & current_solution)
{
  mooseAssert(_preset, "BC is not preset");

  if (_var.isNodalDefined())
  {
    const dof_id_type & dof_idx = _var.nodalDofIndex();
    current_solution.set(dof_idx, computeQpValue());
  }
}

Real
DirichletBCBase::computeQpResidual()
{
  return _u[_qp] - computeQpValue();
}

(moose/framework/src/bcs/FunctionNeumannBC.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 "FunctionNeumannBC.h"
#include "Function.h"

registerMooseObject("MooseApp", FunctionNeumannBC);

InputParameters
FunctionNeumannBC::validParams()
{
  InputParameters params = IntegratedBC::validParams();
  params.addRequiredParam<FunctionName>("function", "The function.");
  params.addClassDescription("Imposes the integrated boundary condition "
                             "$\\frac{\\partial u}{\\partial n}=h(t,\\vec{x})$, "
                             "where $h$ is a (possibly) time and space-dependent MOOSE Function.");
  return params;
}

FunctionNeumannBC::FunctionNeumannBC(const InputParameters & parameters)
  : IntegratedBC(parameters), _func(getFunction("function"))
{
}

Real
FunctionNeumannBC::computeQpResidual()
{
  return -_test[_i][_qp] * _func.value(_t, _q_point[_qp]);
}