FVInterfaceKernel.h

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
 
#pragma once
 
// MOOSE
#include "MooseObject.h"
#include "SetupInterface.h"
#include "ParallelUniqueId.h"
#include "FunctionInterface.h"
#include "DistributionInterface.h"
#include "UserObjectInterface.h"
#include "TransientInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "GeometricSearchInterface.h"
#include "BoundaryRestrictableRequired.h"
#include "MeshChangedInterface.h"
#include "TaggingInterface.h"
#include "NeighborCoupleableMooseVariableDependencyIntermediateInterface.h"
#include "TwoMaterialPropertyInterface.h"
#include "ADFunctorInterface.h"
#include "FVFaceResidualObject.h"
#include "FaceArgInterface.h"
 
#include <set>
 
class MooseMesh;
class SubProblem;
class FEProblemBase;
class SystemBase;
class Assembly;
template <typename>
class MooseVariableFV;
 
class FVInterfaceKernel : public MooseObject,
                          public BoundaryRestrictableRequired,
                          public SetupInterface,
                          public FunctionInterface,
                          public DistributionInterface,
                          public UserObjectInterface,
                          public TransientInterface,
                          public PostprocessorInterface,
                          public VectorPostprocessorInterface,
                          public GeometricSearchInterface,
                          public MeshChangedInterface,
                          public TaggingInterface,
                          public NeighborCoupleableMooseVariableDependencyIntermediateInterface,
                          public TwoMaterialPropertyInterface,
                          public ADFunctorInterface,
                          public FVFaceResidualObject,
                          public FaceArgProducerInterface
{
public:
  FVInterfaceKernel(const InputParameters & parameters);
 
  static InputParameters validParams();
 
  const SubProblem & subProblem() const { return _subproblem; }
 
  void computeResidual(const FaceInfo & fi) override;
  void computeJacobian(const FaceInfo & fi) override;
  void computeResidualAndJacobian(const FaceInfo & fi) override;
 
  bool checkFaceIntegrity(const FaceInfo & fi) const;
 
  bool hasFaceSide(const FaceInfo & fi, bool fi_elem_side) const override;
 
protected:
  virtual ADReal computeQpResidual() = 0;
 
  const std::set<SubdomainID> & sub1() const { return _subdomain1; }
 
  const std::set<SubdomainID> & sub2() const { return _subdomain2; }
 
  const MooseVariableFV<Real> & var1() const { return _var1; }
 
  const MooseVariableFV<Real> & var2() const { return _var2; }
 
  const MooseMesh & mesh() const { return _mesh; }
 
  void setupData(const FaceInfo & fi);
 
  void addResidualToVariable1(Real residual);
 
  void addResidualToVariable2(Real residual);
 
  void addResidualAndJacobianToVariable1(const ADReal & residual);
 
  void addResidualAndJacobianToVariable2(const ADReal & residual);
 
  Point normal() const;
 
 
  const Elem & elem1() const;
  const Elem & elem2() const;
 
 
  const Point & centroid1() const;
  const Point & centroid2() const;
 
 
  Moose::ElemArg elemArg1(bool correct_skewness = false) const;
  Moose::ElemArg elemArg2(bool correct_skewness = false) const;
 
 
  Moose::FaceArg
  faceArg1(Moose::FV::LimiterType limiter_type = Moose::FV::LimiterType::CentralDifference,
           bool correct_skewness = false,
           const Moose::StateArg * state_limiter = nullptr) const;
  Moose::FaceArg
  faceArg2(Moose::FV::LimiterType limiter_type = Moose::FV::LimiterType::CentralDifference,
           bool correct_skewness = false,
           const Moose::StateArg * state_limiter = nullptr) const;
 
 
  template <typename FunctorType>
  Moose::FaceArg
  faceArg1(const FunctorType & functor,
           Moose::FV::LimiterType limiter_type = Moose::FV::LimiterType::CentralDifference,
           bool correct_skewness = false,
           const Moose::StateArg * state_limiter = nullptr) const;
 
  template <typename FunctorType>
  Moose::FaceArg
  faceArg2(const FunctorType & functor,
           Moose::FV::LimiterType limiter_type = Moose::FV::LimiterType::CentralDifference,
           bool correct_skewness = false,
           const Moose::StateArg * state_limiter = nullptr) const;
 
  ADReal interpolateValue(Moose::FV::InterpMethod method,
                          const ADReal & value1,
                          const ADReal & value2) const;
 
  const unsigned int _qp = 0;
 
  const FaceInfo * _face_info = nullptr;
 
  const THREAD_ID _tid;
 
  SubProblem & _subproblem;
 
  MooseVariableFV<Real> & _var1;
  MooseVariableFV<Real> & _var2;
 
  Assembly & _assembly;
 
private:
  void addResidual(Real residual, unsigned int var_num, bool neighbor);
 
  void addResidualAndJacobian(const ADReal & residual,
                              const MooseVariableFV<Real> & variable,
                              bool side_is_one);
 
  std::set<SubdomainID> _subdomain1;
  std::set<SubdomainID> _subdomain2;
 
  bool _face_info_elem_on_side1 = false;
 
  const MooseMesh & _mesh;
};
 
template <typename FunctorType>
inline Moose::FaceArg
FVInterfaceKernel::faceArg1(const FunctorType & functor,
                            const Moose::FV::LimiterType limiter_type,
                            const bool correct_skewness,
                            const Moose::StateArg * state_limiter) const
{
  if (!functor.hasFaceSide(*_face_info, _face_info_elem_on_side1))
    mooseError("The functor '",
               functor.functorName(),
               "' is not defined on side 1 of FVInterfaceKernel '",
               name(),
               "' at face centroid ",
               _face_info->faceCentroid(),
               ".");
 
  return faceArg1(limiter_type, correct_skewness, state_limiter);
}
 
template <typename FunctorType>
inline Moose::FaceArg
FVInterfaceKernel::faceArg2(const FunctorType & functor,
                            const Moose::FV::LimiterType limiter_type,
                            const bool correct_skewness,
                            const Moose::StateArg * state_limiter) const
{
  if (!functor.hasFaceSide(*_face_info, !_face_info_elem_on_side1))
    mooseError("The functor '",
               functor.functorName(),
               "' is not defined on side 2 of FVInterfaceKernel '",
               name(),
               "' at face centroid ",
               _face_info->faceCentroid(),
               ".");
 
  return faceArg2(limiter_type, correct_skewness, state_limiter);
}