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 "INSFVMomentumPressureFlux.h"
      11             : #include "INSFVVelocityVariable.h"
      12             : #include "NS.h"
      13             : 
      14             : registerMooseObject("NavierStokesApp", INSFVMomentumPressureFlux);
      15             : 
      16             : InputParameters
      17         172 : INSFVMomentumPressureFlux::validParams()
      18             : {
      19         172 :   auto params = FVFluxKernel::validParams();
      20         172 :   params += INSFVMomentumResidualObject::validParams();
      21         172 :   params.addClassDescription("Momentum pressure term eps grad_P, as a flux kernel "
      22             :                              "using the divergence theoreom, in the  "
      23             :                              "incompressible Navier-Stokes momentum equation.");
      24         172 :   params.addRequiredParam<MooseFunctorName>(NS::pressure, "The pressure");
      25         172 :   return params;
      26           0 : }
      27             : 
      28          88 : INSFVMomentumPressureFlux::INSFVMomentumPressureFlux(const InputParameters & params)
      29          88 :   : FVFluxKernel(params), INSFVMomentumResidualObject(*this), _p(getFunctor<ADReal>(NS::pressure))
      30             : {
      31          88 :   if (!dynamic_cast<INSFVVelocityVariable *>(&_var))
      32           0 :     mooseError("INSFVMomentumPressureFlux may only be used with a Navier-Stokes velocity, "
      33             :                "of variable type INSFVSuperficialVelocityVariable.");
      34          88 : }
      35             : 
      36             : ADReal
      37      119358 : INSFVMomentumPressureFlux::computeQpResidual()
      38             : {
      39             :   ADReal eps_p_interface;
      40             :   // Momentum and porosity domains should match
      41      119358 :   const auto & face_type = _face_info->faceType(std::make_pair(_var.number(), _var.sys().number()));
      42      119358 :   const bool use_elem = (face_type == FaceInfo::VarFaceNeighbors::ELEM) ||
      43             :                         (face_type == FaceInfo::VarFaceNeighbors::BOTH);
      44             : 
      45      119358 :   const auto * const elem_ptr = use_elem ? &_face_info->elem() : _face_info->neighborPtr();
      46      119358 :   const auto & elem = makeElemArg(elem_ptr);
      47      119358 :   const auto state = determineState();
      48             : 
      49      119358 :   if (onBoundary(*_face_info))
      50       29916 :     eps_p_interface = epsilon()(elem, state) * _p(singleSidedFaceArg(), state);
      51             :   else
      52             :   {
      53      104400 :     const auto * neighbor_ptr = use_elem ? _face_info->neighborPtr() : &_face_info->elem();
      54      104400 :     const auto & neighbor = makeElemArg(neighbor_ptr);
      55             : 
      56      104400 :     Moose::FV::interpolate(Moose::FV::InterpMethod::Average,
      57             :                            eps_p_interface,
      58      104400 :                            epsilon()(elem, state) * _p(elem, state),
      59      208800 :                            epsilon()(neighbor, state) * _p(neighbor, state),
      60      104400 :                            *_face_info,
      61             :                            true);
      62             :   }
      63             : 
      64      238716 :   return eps_p_interface * _normal(_index);
      65             : }