Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "FVDiffusionInterface.h"
      11             : #include "MathFVUtils.h"
      12             : 
      13             : registerMooseObject("MooseApp", FVDiffusionInterface);
      14             : 
      15             : InputParameters
      16       14515 : FVDiffusionInterface::validParams()
      17             : {
      18       14515 :   InputParameters params = FVInterfaceKernel::validParams();
      19       14515 :   params.addClassDescription("Computes the residual for diffusion operator across an interface for "
      20             :                              "the finite volume method.");
      21       14515 :   params.addRequiredParam<MaterialPropertyName>("coeff1",
      22             :                                                 "The diffusion coefficient on the 1st subdomain");
      23       14515 :   params.addRequiredParam<MaterialPropertyName>("coeff2",
      24             :                                                 "The diffusion coefficient on the 2nd subdomain");
      25       14515 :   MooseEnum coeff_interp_method("average harmonic", "harmonic");
      26       14515 :   params.addParam<MooseEnum>(
      27             :       "coeff_interp_method",
      28             :       coeff_interp_method,
      29             :       "Switch that can select face interpolation method for diffusion coefficients.");
      30       29030 :   return params;
      31       14515 : }
      32             : 
      33         130 : FVDiffusionInterface::FVDiffusionInterface(const InputParameters & params)
      34             :   : FVInterfaceKernel(params),
      35         130 :     _coeff1(getFunctor<ADReal>("coeff1")),
      36         260 :     _coeff2(getFunctor<ADReal>("coeff2"))
      37             : {
      38         130 :   const auto & interp_method = getParam<MooseEnum>("coeff_interp_method");
      39         130 :   if (interp_method == "average")
      40          39 :     _coeff_interp_method = Moose::FV::InterpMethod::Average;
      41          91 :   else if (interp_method == "harmonic")
      42          91 :     _coeff_interp_method = Moose::FV::InterpMethod::HarmonicAverage;
      43         130 : }
      44             : 
      45             : ADReal
      46       13336 : FVDiffusionInterface::computeQpResidual()
      47             : {
      48       13336 :   const auto & coef_elem = elemIsOne() ? _coeff1 : _coeff2;
      49       13336 :   const auto & coef_neighbor = elemIsOne() ? _coeff2 : _coeff1;
      50             : 
      51             :   // Form a finite difference gradient across the interface
      52       13336 :   Point one_over_gradient_support = _face_info->elemCentroid() - _face_info->neighborCentroid();
      53       13336 :   one_over_gradient_support /= (one_over_gradient_support * one_over_gradient_support);
      54       13336 :   const auto state = determineState();
      55       34308 :   const auto gradient = elemIsOne() ? (var1().getElemValue(&_face_info->elem(), state) -
      56       20972 :                                        var2().getElemValue(_face_info->neighborPtr(), state)) *
      57             :                                           one_over_gradient_support
      58       19036 :                                     : (var1().getElemValue(_face_info->neighborPtr(), state) -
      59       19036 :                                        var2().getElemValue(&_face_info->elem(), state)) *
      60       40008 :                                           -one_over_gradient_support;
      61             : 
      62       13336 :   ADReal diffusivity;
      63       13336 :   interpolate(_coeff_interp_method,
      64             :               diffusivity,
      65       26672 :               coef_elem(elemArg(), determineState()),
      66       26672 :               coef_neighbor(neighborArg(), determineState()),
      67       13336 :               *_face_info,
      68             :               true);
      69             : 
      70       40008 :   return -diffusivity * _normal * gradient;
      71       13336 : }