LinearFVRobinCHTBC.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 "LinearFVRobinCHTBC.h"
#include "NS.h"
 
registerMooseObject("NavierStokesApp", LinearFVRobinCHTBC);
 
InputParameters
LinearFVRobinCHTBC::validParams()
{
  InputParameters params = LinearFVAdvectionDiffusionBC::validParams();
  params.addRequiredParam<MooseFunctorName>("h", "The convective heat transfer coefficient.");
  params.addRequiredParam<MooseFunctorName>("incoming_flux",
                                            "The incoming diffusive flux on the interface.");
  params.addRequiredParam<MooseFunctorName>("surface_temperature",
                                            "The prescribed temperature on the interface.");
  params.addRequiredParam<MooseFunctorName>(
      "thermal_conductivity",
      "The thermal conductivity of the material. Only used to compute the pure normal gradient of "
      "the variable on the boundary.");
 
  params.addClassDescription(
      "Conjugate heat transfer BC for Robin boundary condition-based coupling.");
  return params;
}
 
LinearFVRobinCHTBC::LinearFVRobinCHTBC(const InputParameters & parameters)
  : LinearFVAdvectionDiffusionBC(parameters),
    LinearFVCHTBCInterface(),
    _htc(getFunctor<Real>("h")),
    _k(getFunctor<Real>("thermal_conductivity")),
    _incoming_flux(getFunctor<Real>("incoming_flux")),
    _surface_temperature(getFunctor<Real>("surface_temperature"))
{
}
 
Real
LinearFVRobinCHTBC::computeBoundaryValue() const
{
  const auto elem_info = (_current_face_type == FaceInfo::VarFaceNeighbors::ELEM)
                             ? _current_face_info->elemInfo()
                             : _current_face_info->neighborInfo();
 
  return _var.getElemValue(*elem_info, determineState());
}
 
Real
LinearFVRobinCHTBC::computeBoundaryNormalGradient() const
{
  const auto elem_info = (_current_face_type == FaceInfo::VarFaceNeighbors::ELEM)
                             ? _current_face_info->elemInfo()
                             : _current_face_info->neighborInfo();
  const auto state = determineState();
  const auto current_face = singleSidedFaceArg(_current_face_info);
  const auto surface_temperature_face = functorFaceArg(_surface_temperature, _current_face_info);
  const auto incoming_flux_face = functorFaceArg(_incoming_flux, _current_face_info);
 
  return (_htc(current_face, state) * (_var.getElemValue(*elem_info, determineState()) -
                                       _surface_temperature(surface_temperature_face, state)) +
          _incoming_flux(incoming_flux_face, state)) /
         _k(current_face, state);
}
 
Real
LinearFVRobinCHTBC::computeBoundaryValueMatrixContribution() const
{
  // We approximate the face value with the cell value here.
  // TODO: we can extend this to a 2-term expansion at some point when the need arises.
  return 1.0;
}
 
Real
LinearFVRobinCHTBC::computeBoundaryValueRHSContribution() const
{
  // We approximate the face value with the cell value, we
  // don't need to add anything to the right hand side.
  return 0.0;
}
 
Real
LinearFVRobinCHTBC::computeBoundaryGradientMatrixContribution() const
{
  const auto face = singleSidedFaceArg(_current_face_info);
  const auto state = determineState();
 
  // We just put the heat transfer coefficient on the diagonal (multiplication with the
  // surface area is taken care of in the kernel).
  return _htc(face, state);
}
Real
LinearFVRobinCHTBC::computeBoundaryGradientRHSContribution() const
{
  const auto state = determineState();
  const auto current_face = singleSidedFaceArg(_current_face_info);
  const auto surface_temperature_face = functorFaceArg(_surface_temperature, _current_face_info);
  const auto incoming_flux_face = functorFaceArg(_incoming_flux, _current_face_info);
 
  return _htc(current_face, state) * _surface_temperature(surface_temperature_face, state) +
         _incoming_flux(incoming_flux_face, state);
}