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;
};