FVAdvectedInterpolationMethod.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 "FaceInfo.h"
#include "GradientLimiterType.h"
#include "MooseFunctor.h"
 
#include <utility>
 
class FVAdvectedInterpolationMethod
{
public:
  struct AdvectedSystemContribution
  {
    std::pair<Real, Real> weights_matrix;
    Real rhs_face_value = 0.0;
  };
 
  virtual AdvectedSystemContribution advectedInterpolate(const FaceInfo & face,
                                                         Real elem_value,
                                                         Real neighbor_value,
                                                         const VectorValue<Real> * elem_grad,
                                                         const VectorValue<Real> * neighbor_grad,
                                                         Real mass_flux) const = 0;
 
  AdvectedSystemContribution advectedInterpolate(const Moose::FunctorBase<Real> & functor,
                                                 const FaceInfo & face,
                                                 const Moose::StateArg & state,
                                                 const Real mass_flux) const;
 
  virtual Real advectedInterpolateValue(const FaceInfo & face,
                                        Real elem_value,
                                        Real neighbor_value,
                                        const VectorValue<Real> * elem_grad,
                                        const VectorValue<Real> * neighbor_grad,
                                        Real mass_flux) const;
 
  Real advectedInterpolateValue(const Moose::FunctorBase<Real> & functor,
                                const FaceInfo & face,
                                const Moose::StateArg & state,
                                const Real mass_flux) const;
 
  virtual bool needsGradients() const { return false; }
 
  virtual Moose::FV::GradientLimiterType gradientLimiter() const
  {
    return Moose::FV::GradientLimiterType::None;
  }
};