FVFluxKernel.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
 
#include "FVKernel.h"
#include "MathFVUtils.h"
#include "NeighborCoupleable.h"
#include "TwoMaterialPropertyInterface.h"
#include "NeighborMooseVariableInterface.h"
#include "NeighborCoupleableMooseVariableDependencyIntermediateInterface.h"
#include "FVFaceResidualObject.h"
#include "FaceArgInterface.h"
 
class FaceInfo;
 
class FVFluxKernel : public FVKernel,
                     public TwoMaterialPropertyInterface,
                     public NeighborMooseVariableInterface<Real>,
                     public NeighborCoupleableMooseVariableDependencyIntermediateInterface,
                     public FVFaceResidualObject,
                     public FaceArgProducerInterface
{
public:
  static InputParameters validParams();
  FVFluxKernel(const InputParameters & params);
 
  void computeResidual() override;
  void computeJacobian() override;
  void computeResidualAndJacobian() override;
  void computeResidual(const FaceInfo & fi) override;
  void computeJacobian(const FaceInfo & fi) override;
  void computeResidualAndJacobian(const FaceInfo & fi) override;
 
  const MooseVariableFV<Real> & variable() const override { return _var; }
 
  bool hasFaceSide(const FaceInfo & fi, const bool fi_elem_side) const override;
 
protected:
  virtual ADReal computeQpResidual() = 0;
 
  virtual ADReal gradUDotNormal(const Moose::StateArg & time, const bool correct_skewness) const;
 
  virtual bool skipForBoundary(const FaceInfo & fi) const;
 
  const RealVectorValue & normal() const { return _normal; }
 
  MooseVariableFV<Real> & _var;
 
  const unsigned int _qp = 0;
 
  RealVectorValue _normal;
 
  const FaceInfo * _face_info = nullptr;
 
  FaceInfo::VarFaceNeighbors _face_type;
 
  bool onBoundary(const FaceInfo & fi) const;
 
  Moose::ElemArg elemArg(bool correct_skewness = false) const;
 
  Moose::ElemArg neighborArg(bool correct_skewness = false) const;
 
  Moose::FaceArg singleSidedFaceArg(
      const FaceInfo * fi = nullptr,
      Moose::FV::LimiterType limiter_type = Moose::FV::LimiterType::CentralDifference,
      bool correct_skewness = false,
      const Moose::StateArg * state_limiter = nullptr) const;
 
  bool avoidBoundary(const FaceInfo & fi) const;
 
  std::unordered_set<BoundaryID> _boundaries_to_force;
 
private:
  const bool _force_boundary_execution;
 
  std::unordered_set<BoundaryID> _boundaries_to_avoid;
};