FVDiffusionInterface.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 "FVDiffusionInterface.h"
 
registerMooseObject("MooseApp", FVDiffusionInterface);
 
InputParameters
FVDiffusionInterface::validParams()
{
  InputParameters params = FVInterfaceKernel::validParams();
  params.addClassDescription("Computes the residual for diffusion operator across an interface for "
                             "the finite volume method.");
  params.addRequiredParam<MaterialPropertyName>("coeff1",
                                                "The diffusion coefficient on the 1st subdomain");
  params.addRequiredParam<MaterialPropertyName>("coeff2",
                                                "The diffusion coefficient on the 2nd subdomain");
  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.");
  return params;
}
 
FVDiffusionInterface::FVDiffusionInterface(const InputParameters & params)
  : FVInterfaceKernel(params),
    _coeff1(getFunctor<ADReal>("coeff1")),
    _coeff2(getFunctor<ADReal>("coeff2"))
{
  const auto & interp_method = getParam<MooseEnum>("coeff_interp_method");
  if (interp_method == "average")
    _coeff_interp_method = Moose::FV::InterpMethod::Average;
  else if (interp_method == "harmonic")
    _coeff_interp_method = Moose::FV::InterpMethod::HarmonicAverage;
}
 
ADReal
FVDiffusionInterface::computeQpResidual()
{
  // Form a finite difference gradient across the interface
  Point one_over_gradient_support = centroid1() - centroid2();
  one_over_gradient_support /= (one_over_gradient_support * one_over_gradient_support);
  const auto state = determineState();
  const auto gradient =
      (var1().getElemValue(&elem1(), state) - var2().getElemValue(&elem2(), state)) *
      one_over_gradient_support;
 
  const auto diffusivity = interpolateValue(
      _coeff_interp_method, _coeff1(elemArg1(), state), _coeff2(elemArg2(), state));
 
  return -diffusivity * normal() * gradient;
}