FVKernels System

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

For the finite volume method (FVM), FVKernels are the base class for FVFluxKernel, FVElementalKernel. These specialized objects satisfy the following tasks:

* FVFluxKernel represents numerical fluxes evaluate on the element faces. These terms originate from applying Gauss' divergence theorem.

* FVElementalKernel represents terms that do not contain a spatial derivative so that Gauss' theorem cannot be applied. These terms include time derivatives, externally imposed source terms, and reaction terms.

Note: Currently, the FVElementalKernel category only contains kernels (subclasses) representing time derivatives. Kernels representing externally imposed sources or reaction terms will be added in the near future.

note

In the documentation that follows, we will use '-' and '' to represent different sides of a face. This is purely notation. In the MOOSE code base, the '-' side is represented with an _elem suffix and the '' side is represented with a _neighbor suffix. We could just as well have chosen _left and _right, or _1 and _2, or _minus and _plus, but for consistency with previous MOOSE framework code such as discontinuous Galerkin kernels and node-face constraints, we have elected to go with the _elem and _neighbor suffixes.

FVKernels block

FVM kernels are added to simulation input files in the FVKernels block. The FVKernels block in the example below sets up a transient diffusion problem defined by the equation:

$var element = document.getElementById("moose-equation-64438901-e117-421f-963e-dc6c5eeb6852");katex.render(" \\frac{\\partial v}{\\partial t} - \\nabla \\cdot D \\nabla v = 0.", element, {displayMode:true,throwOnError:false});$

The time derivative term corresponds to the kernel named time, while the diffusion term is represented by the kernel named diff.

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

[FVKernels]
  [./time]
    type = FVFunctorTimeKernel
    variable = v
  [../]
  [diff]
    type = FVDiffusion
    variable = v
    coeff = coeff
  []
[]

The FVTimeKernel in the example derives from FVElementalKernel so it's a volumetric contribution to the residual, while the FVDiffusion kernel is an FVFluxKernel and it's a face contribution to the residual. The remaining MOOSE syntax is what you would expect to see in finite element kernel objects:

* variable refers to the variable that this kernel is acting on (i.e. into which equation does the residual of this term go). This must be a finite-volume variable (defined with fv = true) for all FVM kernels.

* coeff in kernel diff is a material property corresponding to the heat conduction or diffusion coefficient.

The next example shows an FVKernels block that solves the one-dimensional Burgers' equation. The Burgers' equation for speed v is given by:

$var element = document.getElementById("moose-equation-21139d1a-44c0-4ffb-9479-ade3384fcb69");katex.render(" \\frac{\\partial v}{\\partial t} + \\frac{1}{2}\\frac{\\partial }{\\partial x} v^2 = 0.", element, {displayMode:true,throwOnError:false});$

Listing 2: Example of the FVKernels block in a MOOSE input file for solving one-dimensional Burgers' equation.

[FVKernels]
  [./burgers]
    type = FVBurgers1D
    variable = v
  [../]
  [./time]
    type = FVTimeKernel
    variable = v
  [../]
[]

Note that the FVBurgers1D kernel only works for one-dimensional problems. In this example, the exact same time derivative kernels as for the diffusion example is used, but the spatial derivative term is different.

Boundary conditions are not discussed in these examples. Look at syntax files for details about boundary conditions.

Available Objects

Moose App
FVAdvectionResidual contribution from advection operator for finite volume method.
FVAnisotropicDiffusionComputes residual for anisotropic diffusion operator for finite volume method.
FVBodyForceDemonstrates the multiple ways that scalar values can be introduced into finite volume kernels, e.g. (controllable) constants, functions, and postprocessors.
FVBoundedValueConstraintThis class is used to enforce a min or max value for a finite volume variable
FVCoupledForceImplements a source term proportional to the value of a coupled variable.
FVDiffusionComputes residual for diffusion operator for finite volume method.
FVDivergenceComputes the residual coming from the divergence of a vector fieldthat can be represented as a functor.
FVFunctorTimeKernelResidual contribution from time derivative of an AD functor (default is the variable this kernel is acting upon if the 'functor' parameter is not supplied) for the finite volume method.
FVIntegralValueConstraintThis class is used to enforce integral of phi = volume * phi_0 with a Lagrange multiplier approach.
FVMassMatrixComputes a 'mass matrix', which will just be a diagonal matrix for the finite volume method, meant for use in preconditioning schemes which require one
FVMatAdvectionComputes the residual of advective term using finite volume method.
FVOrthogonalDiffusionImposes an orthogonal diffusion term.
FVPointValueConstraintThis class is used to enforce integral of phi = volume * phi_0 with a Lagrange multiplier approach.
FVReactionSimple consuming reaction term
FVScalarLagrangeMultiplierThis class is used to enforce integral of phi = volume * phi_0 with a Lagrange multiplier approach.
FVTimeKernelResidual contribution from time derivative of a variable for the finite volume method.

FVKernel source code: FVDiffusion example

First, FVFluxKernels are discussed. FVFluxKernels are used to calculate numerical flux contributions from face (surface integral) terms to the residual. The residual contribution is implemented by overriding the computeQpResidual function.

In the FVM, one solves for the averages of the variables over each element. The values of the variables on the faces are unknown and must be computed from the cell average values. This interpolation/reconstruction determines the accuracy of the FVM. The discussion is based on the example of FVDiffusion that discretizes the diffusion term using a central difference approximation.

Listing 3: Example source code for a finite volume kernel discretizing the diffusion term using a central difference.


#include "FVDiffusion.h"

registerMooseObject("MooseApp", FVDiffusion);

InputParameters
FVDiffusion::validParams()
{
  InputParameters params = FVFluxKernel::validParams();
  params.addClassDescription("Computes residual for diffusion operator for finite volume method.");
  params.addRequiredParam<MooseFunctorName>("coeff", "diffusion coefficient");
  MooseEnum coeff_interp_method("average harmonic", "harmonic");
  params.addParam<MooseEnum>(
      "coeff_interp_method",
      coeff_interp_method,
      "Switch that can select face interpolation method for diffusion coefficients.");
  params.set<unsigned short>("ghost_layers") = 2;

  return params;
}

FVDiffusion::FVDiffusion(const InputParameters & params)
  : FVFluxKernel(params),
    _coeff(getFunctor<ADReal>("coeff")),
    _coeff_interp_method(
        Moose::FV::selectInterpolationMethod(getParam<MooseEnum>("coeff_interp_method")))
{
  if ((_var.faceInterpolationMethod() == Moose::FV::InterpMethod::SkewCorrectedAverage) &&
      (_tid == 0))
    adjustRMGhostLayers(std::max((unsigned short)(3), _pars.get<unsigned short>("ghost_layers")));
}

ADReal
FVDiffusion::computeQpResidual()
{
  using namespace Moose::FV;
  const auto state = determineState();

  auto dudn = gradUDotNormal(state);
  ADReal coeff;

  // If we are on internal faces, we interpolate the diffusivity as usual
  if (_var.isInternalFace(*_face_info))
  {
    const ADReal coeff_elem = _coeff(elemArg(), state);
    const ADReal coeff_neighbor = _coeff(neighborArg(), state);
    // If the diffusion coefficients are zero, then we can early return 0 (and avoid warnings if we
    // have a harmonic interpolation)
    if (!coeff_elem.value() && !coeff_neighbor.value())
      return 0;

    interpolate(_coeff_interp_method, coeff, coeff_elem, coeff_neighbor, *_face_info, true);
  }
  // Else we just use the boundary values (which depend on how the diffusion
  // coefficient is constructed)
  else
  {
    const auto face = singleSidedFaceArg();
    coeff = _coeff(face, state);
  }

  return -1 * coeff * dudn;
}

The kernel FVDiffusion discretizes the diffusion term $var element = document.getElementById("moose-equation-5bc8094d-14c0-4127-ac18-10ba5653db09");katex.render("-\\nabla \\cdot D(v,\\vec{r}) \\nabla v", element, {displayMode:false,throwOnError:false});$ . Integrating over the extend of an element and using Gauss' theorem leads to:

$var element = document.getElementById("moose-equation-cb2ce7db-dbd8-4287-b61a-f1d123b56f63");katex.render("- \\int_{\\Omega} \\nabla \\cdot D(v,\\vec{r}) \\nabla v dV = \\int_{\\partial \\Omega} \\left(-D(v, \\vec{r}) \\vec{n}\\cdot \\nabla v \\right) dS.", element, {displayMode:true,throwOnError:false});$

The term in parenthesis in the surface integral on the right hand side must be implemented in the FVKernel. However, there is one more step before we can implement the kernel. We must determine how the values of $var element = document.getElementById("moose-equation-40c9026b-a81a-4b0a-abb5-aad9883ac7d4");katex.render("D", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-aaf2d662-5d09-41e6-9853-4f129ab1b3c0");katex.render("\\nabla v", element, {displayMode:false,throwOnError:false});$ depend on the values of $var element = document.getElementById("moose-equation-5e3bcd28-309b-41a7-886c-148d5a3aed51");katex.render("D", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-76dbd6e2-b67c-4289-b1f7-950a7fab744f");katex.render("v", element, {displayMode:false,throwOnError:false});$ on the '+' and '-' side of the face $var element = document.getElementById("moose-equation-1ce1eba3-b448-4947-9652-3f690ad95c09");katex.render("\\partial \\Omega", element, {displayMode:false,throwOnError:false});$ . In this example, the following approximation is used:

$var element = document.getElementById("moose-equation-ab4cbd15-3641-48d0-84bc-c00070b8d2b0");katex.render(" \\left(-D(\\vec{r}) \\vec{n}\\cdot \\nabla v \\right) \\approx \\frac{D(v_L,\\vec{r}_L) + D(v_R,\\vec{r}_R)}{2} \\frac{v_R - v_L}{\\|\\vec{r}_R - \\vec{r}_L\\|}", element, {displayMode:true,throwOnError:false});$

This is a central difference approximation of the gradient on the face that neglects cross diffusion terms.

Now, the implementation of this numerical flux into FVDiffusion::computeQpResidual is discussed.

* the kernel provides the '-' and '+' values of the variable $var element = document.getElementById("moose-equation-2ed15f70-0bc0-423d-93df-e2d453943d8e");katex.render("v", element, {displayMode:false,throwOnError:false});$ as _u_elem[_qp] and _u_neighbor[_qp]

* the values of the material properties on the '-' side of the face is obtained by _coeff_elem(getADMaterialProperty<Real>("coeff")) while the '+' side value is obtained by calling getNeighborADMaterialProperty<Real>("coeff").

* geometric information about the '-' and '+' adjacent elements is available from the face_info object.

The implementation is then straight forward. The first line of the code computes dudn which corresponds to the term:

$var element = document.getElementById("moose-equation-f7831f62-ba2f-45bf-bb6c-51c2225e7f94");katex.render(" \\text{dudn} = \\frac{v_R - v_L}{\\|\\vec{r}_R - \\vec{r}_L\\|}", element, {displayMode:true,throwOnError:false});$

while the second line computes k corresponding to:

$var element = document.getElementById("moose-equation-4085e11a-f328-48cb-a482-f1067448f131");katex.render(" \\text{k} = \\frac{D(v_L,\\vec{r}_L) + D(v_R,\\vec{r}_R)}{2} .", element, {displayMode:true,throwOnError:false});$

The minus sign originates from the minus sign in the original expression. Flow from '-' to '+ is defined to be positive.

FVKernel source code: FVMatAdvection example

In this example the advection term:

$var element = document.getElementById("moose-equation-fdff7964-66e9-4165-b382-882f97c95756");katex.render(" \\nabla \\cdot \\left( \\vec{u} v \\right)", element, {displayMode:true,throwOnError:false});$

is discretized using upwinding. The velocity is denoted by $var element = document.getElementById("moose-equation-206ad731-9121-47ea-82e1-ef22dec71204");katex.render("\\vec{u}", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-9a399224-deda-4e8e-b521-3c34816531e2");katex.render("v", element, {displayMode:false,throwOnError:false});$ represents a passive scalar quantity advected by the flow. Upwinding is a strategy that approximates the value of a variable on a face by taking the value from the upwind element (i.e. the element where the flow originates from).

Listing 4: Example source code for a finite volume kernel discretizing advection of a passive scalar.


#include "FVDiffusion.h"

registerMooseObject("MooseApp", FVDiffusion);

InputParameters
FVDiffusion::validParams()
{
  InputParameters params = FVFluxKernel::validParams();
  params.addClassDescription("Computes residual for diffusion operator for finite volume method.");
  params.addRequiredParam<MooseFunctorName>("coeff", "diffusion coefficient");
  MooseEnum coeff_interp_method("average harmonic", "harmonic");
  params.addParam<MooseEnum>(
      "coeff_interp_method",
      coeff_interp_method,
      "Switch that can select face interpolation method for diffusion coefficients.");
  params.set<unsigned short>("ghost_layers") = 2;

  return params;
}

FVDiffusion::FVDiffusion(const InputParameters & params)
  : FVFluxKernel(params),
    _coeff(getFunctor<ADReal>("coeff")),
    _coeff_interp_method(
        Moose::FV::selectInterpolationMethod(getParam<MooseEnum>("coeff_interp_method")))
{
  if ((_var.faceInterpolationMethod() == Moose::FV::InterpMethod::SkewCorrectedAverage) &&
      (_tid == 0))
    adjustRMGhostLayers(std::max((unsigned short)(3), _pars.get<unsigned short>("ghost_layers")));
}

ADReal
FVDiffusion::computeQpResidual()
{
  using namespace Moose::FV;
  const auto state = determineState();

  auto dudn = gradUDotNormal(state);
  ADReal coeff;

  // If we are on internal faces, we interpolate the diffusivity as usual
  if (_var.isInternalFace(*_face_info))
  {
    const ADReal coeff_elem = _coeff(elemArg(), state);
    const ADReal coeff_neighbor = _coeff(neighborArg(), state);
    // If the diffusion coefficients are zero, then we can early return 0 (and avoid warnings if we
    // have a harmonic interpolation)
    if (!coeff_elem.value() && !coeff_neighbor.value())
      return 0;

    interpolate(_coeff_interp_method, coeff, coeff_elem, coeff_neighbor, *_face_info, true);
  }
  // Else we just use the boundary values (which depend on how the diffusion
  // coefficient is constructed)
  else
  {
    const auto face = singleSidedFaceArg();
    coeff = _coeff(face, state);
  }

  return -1 * coeff * dudn;
}

Integrating the advection term over the element and using Gauss' theorem leads to:

$var element = document.getElementById("moose-equation-4029d78b-a08b-4347-8354-199e4061ecc4");katex.render(" \\int_{\\Omega} \\nabla \\cdot \\left( \\vec{u} v \\right) dV = \\int_{\\partial \\Omega} \\left(\\vec{n} \\cdot \\vec{u} v \\right) dS.", element, {displayMode:true,throwOnError:false});$

This term in parenthesis on the right hand side is approximated using upwinding:

$var element = document.getElementById("moose-equation-51cf85a8-0d39-4979-9751-a3250756e2f8");katex.render(" \\vec{n} \\cdot \\vec{u} v \\approx \\tilde{\\vec{u}}\\cdot \\vec{n} \\tilde{v} ,", element, {displayMode:true,throwOnError:false});$

where

$var element = document.getElementById("moose-equation-27086890-444c-4c2d-99e2-b8d227f06a78");katex.render(" \\tilde{\\vec{u}} = \\frac{1}{2} \\left( \\vec{u}_L + \\vec{u}_R \\right)", element, {displayMode:true,throwOnError:false});$

and $var element = document.getElementById("moose-equation-8387eb7d-bb9f-4c63-87cd-2bda7386ad8e");katex.render("\\tilde{v} = v_L", element, {displayMode:false,throwOnError:false});$ if $var element = document.getElementById("moose-equation-f490ea51-e138-44bd-ab24-4b9822e2cbd0");katex.render("\\tilde{\\vec{u}} \\cdot \\vec{n} > 0", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-801f5a5a-0e7a-4b38-bf7a-7b8b22962013");katex.render("\\tilde{v} = v_R", element, {displayMode:false,throwOnError:false});$ otherwise. By convention, the normal $var element = document.getElementById("moose-equation-da379c85-ba2e-4de5-9281-3874c0f7be05");katex.render("\\vec{n}", element, {displayMode:false,throwOnError:false});$ points from the '-' side to the '+' side.

The implementation is straight forward. In the constructor the '-' and '' velocities are obtained as RealVectorValue material properties. The average is computed and stored in variable v_avg. The direction of the flow is determined using the inner product of v_avg * _normal and the residual is then computed using either the '-' value of $var element = document.getElementById("moose-equation-e06ed98f-e561-460e-b566-5d9d7ea972f4");katex.render("v", element, {displayMode:false,throwOnError:false});$ given by _u_elem[_qp] or the '' value given by _u_neighbor [_qp].

FVKernel source code: FVTimeKernel

This example demonstrates source code for an FVElementalKernel. FVElementalKernel are volumetric terms. In this case, the kernel is FVTimeKernel.

Listing 5: Example source code for the finite volume time kernel.

FVTimeKernel::computeQpResidual()
{
  return _u_dot[_qp];
}

This kernel implements the term:

$var element = document.getElementById("moose-equation-97f78ab4-5108-43d3-89ef-bb7a1e1446d8");katex.render(" \\frac{\\partial v}{\\partial t}", element, {displayMode:true,throwOnError:false});$

The implementation is identical to the implementation of FEM kernels except that the FVM does not require multiplication by the test function.

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

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

[Variables]
  [v]
    family = MONOMIAL
    order = CONSTANT
    fv = true
    initial_condition = 7
  []
[]

[Kernels]
[]

[FVKernels]
  [./time]
    type = FVFunctorTimeKernel
    variable = v
  [../]
  [diff]
    type = FVDiffusion
    variable = v
    coeff = coeff
  []
[]

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

[Materials]
  [diff]
    type = ADGenericFunctorMaterial
    prop_names = 'coeff'
    prop_values = '.2'
  []
[]

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

[Outputs]
  exodus = true
[]

(moose/test/tests/fvkernels/fv_burgers/fv_burgers.i)

[Mesh]
  [./gen_mesh]
    type = GeneratedMeshGenerator
    dim = 1
    xmin = 0
    xmax = 10
    nx = 50
  [../]
[]

[Variables]
  [./v]
    family = MONOMIAL
    order = CONSTANT
    fv = true
  [../]
[]

[ICs]
  [./v_ic]
    type = FunctionIC
    variable = v
    function = 'if (x > 2 & x < 3, 0.5, 0)'
  [../]
[]

[FVKernels]
  [./burgers]
    type = FVBurgers1D
    variable = v
  [../]
  [./time]
    type = FVTimeKernel
    variable = v
  [../]
[]

[FVBCs]
  [./fv_burgers_outflow]
    type = FVBurgersOutflowBC
    variable = v
    boundary = 'left right'
  [../]
[]

[Executioner]
  type = Transient
  petsc_options_iname = '-pc_type'
  petsc_options_value = 'lu'
  petsc_options = '-snes_converged_reason'
  nl_abs_tol = 1e-7
  nl_rel_tol = 1e-8
  num_steps = 5
  dt = 0.05
[]

[Outputs]
  exodus = true
[]

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

registerMooseObject("MooseApp", FVDiffusion);

InputParameters
FVDiffusion::validParams()
{
  InputParameters params = FVFluxKernel::validParams();
  params.addClassDescription("Computes residual for diffusion operator for finite volume method.");
  params.addRequiredParam<MooseFunctorName>("coeff", "diffusion coefficient");
  MooseEnum coeff_interp_method("average harmonic", "harmonic");
  params.addParam<MooseEnum>(
      "coeff_interp_method",
      coeff_interp_method,
      "Switch that can select face interpolation method for diffusion coefficients.");
  params.set<unsigned short>("ghost_layers") = 2;

  return params;
}

FVDiffusion::FVDiffusion(const InputParameters & params)
  : FVFluxKernel(params),
    _coeff(getFunctor<ADReal>("coeff")),
    _coeff_interp_method(
        Moose::FV::selectInterpolationMethod(getParam<MooseEnum>("coeff_interp_method")))
{
  if ((_var.faceInterpolationMethod() == Moose::FV::InterpMethod::SkewCorrectedAverage) &&
      (_tid == 0))
    adjustRMGhostLayers(std::max((unsigned short)(3), _pars.get<unsigned short>("ghost_layers")));
}

ADReal
FVDiffusion::computeQpResidual()
{
  using namespace Moose::FV;
  const auto state = determineState();

  auto dudn = gradUDotNormal(state);
  ADReal coeff;

  // If we are on internal faces, we interpolate the diffusivity as usual
  if (_var.isInternalFace(*_face_info))
  {
    const ADReal coeff_elem = _coeff(elemArg(), state);
    const ADReal coeff_neighbor = _coeff(neighborArg(), state);
    // If the diffusion coefficients are zero, then we can early return 0 (and avoid warnings if we
    // have a harmonic interpolation)
    if (!coeff_elem.value() && !coeff_neighbor.value())
      return 0;

    interpolate(_coeff_interp_method, coeff, coeff_elem, coeff_neighbor, *_face_info, true);
  }
  // Else we just use the boundary values (which depend on how the diffusion
  // coefficient is constructed)
  else
  {
    const auto face = singleSidedFaceArg();
    coeff = _coeff(face, state);
  }

  return -1 * coeff * dudn;
}

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

registerMooseObject("MooseApp", FVDiffusion);

InputParameters
FVDiffusion::validParams()
{
  InputParameters params = FVFluxKernel::validParams();
  params.addClassDescription("Computes residual for diffusion operator for finite volume method.");
  params.addRequiredParam<MooseFunctorName>("coeff", "diffusion coefficient");
  MooseEnum coeff_interp_method("average harmonic", "harmonic");
  params.addParam<MooseEnum>(
      "coeff_interp_method",
      coeff_interp_method,
      "Switch that can select face interpolation method for diffusion coefficients.");
  params.set<unsigned short>("ghost_layers") = 2;

  return params;
}

FVDiffusion::FVDiffusion(const InputParameters & params)
  : FVFluxKernel(params),
    _coeff(getFunctor<ADReal>("coeff")),
    _coeff_interp_method(
        Moose::FV::selectInterpolationMethod(getParam<MooseEnum>("coeff_interp_method")))
{
  if ((_var.faceInterpolationMethod() == Moose::FV::InterpMethod::SkewCorrectedAverage) &&
      (_tid == 0))
    adjustRMGhostLayers(std::max((unsigned short)(3), _pars.get<unsigned short>("ghost_layers")));
}

ADReal
FVDiffusion::computeQpResidual()
{
  using namespace Moose::FV;
  const auto state = determineState();

  auto dudn = gradUDotNormal(state);
  ADReal coeff;

  // If we are on internal faces, we interpolate the diffusivity as usual
  if (_var.isInternalFace(*_face_info))
  {
    const ADReal coeff_elem = _coeff(elemArg(), state);
    const ADReal coeff_neighbor = _coeff(neighborArg(), state);
    // If the diffusion coefficients are zero, then we can early return 0 (and avoid warnings if we
    // have a harmonic interpolation)
    if (!coeff_elem.value() && !coeff_neighbor.value())
      return 0;

    interpolate(_coeff_interp_method, coeff, coeff_elem, coeff_neighbor, *_face_info, true);
  }
  // Else we just use the boundary values (which depend on how the diffusion
  // coefficient is constructed)
  else
  {
    const auto face = singleSidedFaceArg();
    coeff = _coeff(face, state);
  }

  return -1 * coeff * dudn;
}

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

#include "SystemBase.h"

registerADMooseObject("MooseApp", FVTimeKernel);

InputParameters
FVTimeKernel::validParams()
{
  InputParameters params = FVElementalKernel::validParams();
  params.addClassDescription(
      "Residual contribution from time derivative of a variable for the finite volume method.");
  params.set<MultiMooseEnum>("vector_tags") = "time";
  params.set<MultiMooseEnum>("matrix_tags") = "system time";
  return params;
}

FVTimeKernel::FVTimeKernel(const InputParameters & parameters)
  : FVElementalKernel(parameters), _u_dot(_var.adUDot())
{
  _var.requireQpComputations();
}

ADReal
FVTimeKernel::computeQpResidual()
{
  return _u_dot[_qp];
}

FVKernels block
Available Objects
FVKernel source code : FVDiffusion example
FVKernel source code : FVMatAdvection example
FVKernel source code : FVTimeKernel