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;

  const ADVariableValue & _u_elem;
  const ADVariableValue & _u_neighbor;

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