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       14535 : FVDiffusionInterface::validParams()
      17             : {
      18       14535 :   InputParameters params = FVInterfaceKernel::validParams();
      19       14535 :   params.addClassDescription("Computes the residual for diffusion operator across an interface for "
      20             :                              "the finite volume method.");
      21       14535 :   params.addRequiredParam<MaterialPropertyName>("coeff1",
      22             :                                                 "The diffusion coefficient on the 1st subdomain");
      23       14535 :   params.addRequiredParam<MaterialPropertyName>("coeff2",
      24             :                                                 "The diffusion coefficient on the 2nd subdomain");
      25       14535 :   MooseEnum coeff_interp_method("average harmonic", "harmonic");
      26       14535 :   params.addParam<MooseEnum>(
      27             :       "coeff_interp_method",
      28             :       coeff_interp_method,
      29             :       "Switch that can select face interpolation method for diffusion coefficients.");
      30       29070 :   return params;
      31       14535 : }
      32             : 
      33         140 : FVDiffusionInterface::FVDiffusionInterface(const InputParameters & params)
      34             :   : FVInterfaceKernel(params),
      35         140 :     _coeff1(getFunctor<ADReal>("coeff1")),
      36         280 :     _coeff2(getFunctor<ADReal>("coeff2"))
      37             : {
      38         140 :   const auto & interp_method = getParam<MooseEnum>("coeff_interp_method");
      39         140 :   if (interp_method == "average")
      40          42 :     _coeff_interp_method = Moose::FV::InterpMethod::Average;
      41          98 :   else if (interp_method == "harmonic")
      42          98 :     _coeff_interp_method = Moose::FV::InterpMethod::HarmonicAverage;
      43         140 : }
      44             : 
      45             : ADReal
      46       15043 : FVDiffusionInterface::computeQpResidual()
      47             : {
      48       15043 :   const auto & coef_elem = elemIsOne() ? _coeff1 : _coeff2;
      49       15043 :   const auto & coef_neighbor = elemIsOne() ? _coeff2 : _coeff1;
      50             : 
      51             :   // Form a finite difference gradient across the interface
      52       15043 :   Point one_over_gradient_support = _face_info->elemCentroid() - _face_info->neighborCentroid();
      53       15043 :   one_over_gradient_support /= (one_over_gradient_support * one_over_gradient_support);
      54       15043 :   const auto state = determineState();
      55       38724 :   const auto gradient = elemIsOne() ? (var1().getElemValue(&_face_info->elem(), state) -
      56       23681 :                                        var2().getElemValue(_face_info->neighborPtr(), state)) *
      57             :                                           one_over_gradient_support
      58       21448 :                                     : (var1().getElemValue(_face_info->neighborPtr(), state) -
      59       21448 :                                        var2().getElemValue(&_face_info->elem(), state)) *
      60       45129 :                                           -one_over_gradient_support;
      61             : 
      62       15043 :   ADReal diffusivity;
      63       15043 :   interpolate(_coeff_interp_method,
      64             :               diffusivity,
      65       30086 :               coef_elem(elemArg(), determineState()),
      66       30086 :               coef_neighbor(neighborArg(), determineState()),
      67       15043 :               *_face_info,
      68             :               true);
      69             : 
      70       45129 :   return -diffusivity * _normal * gradient;
      71       15043 : }