QUICKLimiter.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 "Limiter.h"
#include "MathFVUtils.h"
 
namespace Moose
{
namespace FV
{
template <typename T>
class QUICKLimiter : public Limiter<T>
{
public:
  T limit(const T & phi_upwind,
          const T & phi_downwind,
          const VectorValue<T> * grad_phi_upwind,
          const VectorValue<T> * grad_phi_downwind,
          const RealVectorValue & dCD,
          const Real & /* max_value */,
          const Real & /* min_value */,
          const FaceInfo * /* fi */,
          const bool & /* fi_elem_is_upwind */) const override final
  {
    mooseAssert(grad_phi_upwind, "QUICK limiter requires a gradient");
 
    // Compute gradient ratio coefficient
    T limiter;
    if (grad_phi_downwind) // compute full slope-reconstruction limiter for weakly-compressible flow
    {
      const auto & r_f = this->rf_grad(grad_phi_upwind, grad_phi_downwind, dCD);
      const auto & beta = T(1.0); // Ensures TVD compliance
      limiter =
          0 * r_f +
          std::min(beta,
                   std::max(std::min(std::min((1 + 3.0 * r_f) / 4.0, 2.0 * r_f), T(2.0)), T(0.0)));
    }
    else // compute upwind slope reconstruction limiter for compressible flow
    {
      const auto & r_f = Moose::FV::rF(phi_upwind, phi_downwind, *grad_phi_upwind, dCD);
      limiter = (3.0 * r_f) / 4.0;
    }
 
    // Return limiter value
    return limiter;
  }
 
  bool constant() const override final { return false; }
 
  InterpMethod interpMethod() const override final { return InterpMethod::QUICK; }
 
  QUICKLimiter() = default;
};
}
}