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 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; }
 
  virtual bool elemIsOne() const { return _elem_is_one; }
 
  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 addResidual(Real resid, unsigned int var_num, bool neighbor);
 
  using TaggingInterface::addJacobian;
  void addJacobian(const ADReal & resid, dof_id_type dof_index, Real scaling_factor);
 
  Moose::ElemArg elemArg(bool correct_skewness = false) const;
 
  Moose::ElemArg neighborArg(bool correct_skenewss = false) const;
 
  Moose::FaceArg singleSidedFaceArg(
      const MooseVariableFV<Real> & variable,
      const FaceInfo * fi = nullptr,
      Moose::FV::LimiterType limiter_type = Moose::FV::LimiterType::CentralDifference,
      bool correct_skewness = false,
      const Moose::StateArg * state_limiter = nullptr) const;
 
  const unsigned int _qp = 0;
 
  ADRealVectorValue _normal;
 
  const FaceInfo * _face_info = nullptr;
 
  const THREAD_ID _tid;
 
  bool _elem_is_one;
 
  SubProblem & _subproblem;
 
  MooseVariableFV<Real> & _var1;
  MooseVariableFV<Real> & _var2;
 
  Assembly & _assembly;
 
private:
  std::set<SubdomainID> _subdomain1;
  std::set<SubdomainID> _subdomain2;
 
  const MooseMesh & _mesh;
};