LinearFVAdvectionDiffusionFunctorNeumannBC.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "LinearFVAdvectionDiffusionFunctorNeumannBC.h"
 
registerMooseObject("MooseApp", LinearFVAdvectionDiffusionFunctorNeumannBC);
 
InputParameters
LinearFVAdvectionDiffusionFunctorNeumannBC::validParams()
{
  InputParameters params = LinearFVAdvectionDiffusionBC::validParams();
  params.addClassDescription(
      "Adds a fixed diffusive flux BC which can be used for the assembly of linear "
      "finite volume system and whose normal face gradient values are determined "
      "using a functor. This kernel is only designed to work with advection-diffusion problems.");
  params.addRequiredParam<MooseFunctorName>(
      "functor", "The diffusive flux functor for this boundary condition.");
  params.addParam<MooseFunctorName>("diffusion_coeff", 1.0, "The diffusion coefficient.");
  return params;
}
 
LinearFVAdvectionDiffusionFunctorNeumannBC::LinearFVAdvectionDiffusionFunctorNeumannBC(
    const InputParameters & parameters)
  : LinearFVAdvectionDiffusionBC(parameters),
    _functor(getFunctor<Real>("functor")),
    _diffusion_coeff(getFunctor<Real>("diffusion_coeff"))
{
  _var.computeCellGradients();
}
 
Real
LinearFVAdvectionDiffusionFunctorNeumannBC::computeBoundaryValue() const
{
  const auto state = determineState();
  const auto face_arg = makeCDFace(*_current_face_info);
  const auto elem_info = _current_face_type == FaceInfo::VarFaceNeighbors::ELEM
                             ? _current_face_info->elemInfo()
                             : _current_face_info->neighborInfo();
  const Real distance = computeCellToFaceDistance();
  const auto d_cf = computeCellToFaceVector();
  // For non-orthogonal meshes we compute an extra correction vector to increase order accuracy
  // correction_vector is a vector orthogonal to the boundary normal
  const auto correction_vector =
      (d_cf - (d_cf * _current_face_info->normal()) * _current_face_info->normal());
  return _var.getElemValue(*elem_info, state) +
         _functor(singleSidedFaceArg(_current_face_info), state) /
             _diffusion_coeff(face_arg, state) * distance +
         _var.gradSln(*elem_info, state) * correction_vector;
}
 
Real
LinearFVAdvectionDiffusionFunctorNeumannBC::computeBoundaryNormalGradient() const
{
  const auto state = determineState();
  const auto face_arg = makeCDFace(*_current_face_info);
  return _functor(singleSidedFaceArg(_current_face_info), state) /
         _diffusion_coeff(face_arg, state);
}
 
Real
LinearFVAdvectionDiffusionFunctorNeumannBC::computeBoundaryValueMatrixContribution() const
{
  return 1.0;
}
 
Real
LinearFVAdvectionDiffusionFunctorNeumannBC::computeBoundaryValueRHSContribution() const
{
  const auto state = determineState();
  const auto face_arg = makeCDFace(*_current_face_info);
  const auto elem_info = _current_face_type == FaceInfo::VarFaceNeighbors::ELEM
                             ? _current_face_info->elemInfo()
                             : _current_face_info->neighborInfo();
 
  // Fetch the boundary value from the provided functor.
  const Real distance = computeCellToFaceDistance();
  const auto d_cf = computeCellToFaceVector();
  // For non-orthogonal meshes we compute an extra correction vector to increase order accuracy
  // correction_vector is a vector orthogonal to the boundary normal
  const auto correction_vector =
      (d_cf - (d_cf * _current_face_info->normal()) * _current_face_info->normal());
  return _functor(singleSidedFaceArg(_current_face_info), state) /
             _diffusion_coeff(face_arg, state) * distance +
         _var.gradSln(*elem_info, state) * correction_vector;
}
 
Real
LinearFVAdvectionDiffusionFunctorNeumannBC::computeBoundaryGradientMatrixContribution() const
{
  return 0.0;
}
 
Real
LinearFVAdvectionDiffusionFunctorNeumannBC::computeBoundaryGradientRHSContribution() const
{
  return _functor(singleSidedFaceArg(_current_face_info), determineState());
}