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 "PINSFVEnergyDiffusion.h"
      11             : #include "INSFVEnergyVariable.h"
      12             : #include "NS.h"
      13             : 
      14             : registerMooseObject("NavierStokesApp", PINSFVEnergyDiffusion);
      15             : 
      16             : InputParameters
      17         979 : PINSFVEnergyDiffusion::validParams()
      18             : {
      19         979 :   auto params = FVFluxKernel::validParams();
      20         979 :   params += FVDiffusionInterpolationInterface::validParams();
      21         979 :   params.addClassDescription("Diffusion term in the porous media incompressible Navier-Stokes "
      22             :                              "fluid energy equations :  $-div(eps * k * grad(T))$");
      23         979 :   params.addRequiredParam<MooseFunctorName>(NS::porosity, "Porosity");
      24         979 :   params.addRequiredParam<MooseFunctorName>(NS::k, "Thermal conductivity");
      25        1958 :   params.addParam<bool>(
      26             :       "effective_diffusivity",
      27        1958 :       false,
      28             :       "Whether the conductivity should be multiplied by porosity, or whether the provided "
      29             :       "conductivity is an effective conductivity taking porosity effects into account");
      30        1958 :   params.renameParam("effective_diffusivity", "effective_conductivity", "");
      31        1958 :   MooseEnum coeff_interp_method("average harmonic", "harmonic");
      32        1958 :   params.addParam<MooseEnum>(
      33             :       "kappa_interp_method",
      34             :       coeff_interp_method,
      35             :       "Switch that can select face interpolation method for the thermal conductivity.");
      36             : 
      37             :   // We add the relationship manager here, this will select the right number of
      38             :   // ghosting layers depending on the chosen interpolation method
      39        1958 :   params.addRelationshipManager(
      40             :       "ElementSideNeighborLayers",
      41             :       Moose::RelationshipManagerType::GEOMETRIC | Moose::RelationshipManagerType::ALGEBRAIC |
      42             :           Moose::RelationshipManagerType::COUPLING,
      43             :       [](const InputParameters & obj_params, InputParameters & rm_params)
      44         552 :       { FVRelationshipManagerInterface::setRMParamsDiffusion(obj_params, rm_params, 3); });
      45             : 
      46         979 :   params.set<unsigned short>("ghost_layers") = 2;
      47         979 :   return params;
      48         979 : }
      49             : 
      50         531 : PINSFVEnergyDiffusion::PINSFVEnergyDiffusion(const InputParameters & params)
      51             :   : FVFluxKernel(params),
      52             :     SolutionInvalidInterface(this),
      53             :     FVDiffusionInterpolationInterface(params),
      54         531 :     _k(getFunctor<ADReal>(NS::k)),
      55         531 :     _eps(getFunctor<ADReal>(NS::porosity)),
      56        1062 :     _porosity_factored_in(getParam<bool>("effective_conductivity")),
      57         531 :     _k_interp_method(
      58        1593 :         Moose::FV::selectInterpolationMethod(getParam<MooseEnum>("kappa_interp_method")))
      59             : {
      60         531 :   if (!dynamic_cast<INSFVEnergyVariable *>(&_var))
      61           0 :     mooseError("PINSFVEnergyDiffusion may only be used with a fluid temperature variable, "
      62             :                "of variable type INSFVEnergyVariable.");
      63         531 : }
      64             : 
      65             : ADReal
      66     4712654 : PINSFVEnergyDiffusion::computeQpResidual()
      67             : {
      68             :   // Interpolate thermal conductivity times porosity on the face
      69             :   ADReal k_eps_face;
      70     4712654 :   const auto state = determineState();
      71             : 
      72     4712654 :   if (onBoundary(*_face_info))
      73             :   {
      74       20927 :     const auto ssf = singleSidedFaceArg();
      75       71063 :     k_eps_face = _porosity_factored_in ? _k(ssf, state) : _k(ssf, state) * _eps(ssf, state);
      76             :   }
      77             :   else
      78             :   {
      79     4691727 :     const auto face_elem = elemArg();
      80     4691727 :     const auto face_neighbor = neighborArg();
      81             : 
      82     4691727 :     auto value1 = _porosity_factored_in ? _k(face_elem, state)
      83     9230656 :                                         : _k(face_elem, state) * _eps(face_elem, state);
      84     4691727 :     auto value2 = _porosity_factored_in ? _k(face_neighbor, state)
      85     9230656 :                                         : _k(face_neighbor, state) * _eps(face_neighbor, state);
      86             : 
      87             :     // Adapt to users either passing 0 thermal conductivity, 0 porosity, or k correlations going
      88             :     // negative. The solution is invalid only for the latter case.
      89     4691727 :     auto k_interp_method = _k_interp_method;
      90     4691727 :     if (value1 <= 0 || value2 <= 0)
      91             :     {
      92           0 :       flagInvalidSolution(
      93             :           "Negative or null thermal conductivity value. If this is on purpose use arithmetic mean "
      94             :           "interpolation instead of the default harmonic interpolation.");
      95           0 :       if (_k_interp_method == Moose::FV::InterpMethod::HarmonicAverage)
      96             :         k_interp_method = Moose::FV::InterpMethod::Average;
      97           0 :       if (value1 < 0)
      98           0 :         value1 = 0;
      99           0 :       if (value2 < 0)
     100           0 :         value2 = 0;
     101             :     }
     102             : 
     103     4691727 :     Moose::FV::interpolate(k_interp_method, k_eps_face, value1, value2, *_face_info, true);
     104             :   }
     105             : 
     106             :   // Compute the temperature gradient dotted with the surface normal
     107     4712654 :   auto dTdn = gradUDotNormal(state, _correct_skewness);
     108             : 
     109     9425308 :   return -k_eps_face * dTdn;
     110             : }