minmod_limiter.hh

Go to the documentation of this file.

#pragma once
 
// DiFfRG
#include <DiFfRG/discretization/FV/limiter/abstract_limiter.hh>
 
// standard library
#include <algorithm>
#include <cmath>
#include <cstddef>
 
// autodiff
#include <autodiff/forward/real/real.hpp>
 
namespace DiFfRG
{
  namespace def
  {
    class MinModLimiter
    {
      template <typename NumberType> static NumberType abs_with_zero_tie_derivative(const NumberType &value)
      {
        using std::abs;
        return abs(value);
      }
 
      template <size_t order, typename NumberType>
      static autodiff::Real<order, NumberType>
      abs_with_zero_tie_derivative(const autodiff::Real<order, NumberType> &value)
      {
        using std::abs;
        if (std::abs(value.val()) < 1.0e-8) return autodiff::Real<order, NumberType>(0.0);
        return abs(value);
      }
 
    public:
      template <typename NumberType> static NumberType slope_limit(const NumberType &du_1, const NumberType &du_2)
      {
        // Use the algebraic identity min(a,b) = 0.5*(a+b-|a-b|) instead of std::min so that
        // AD follows the active branch away from ties without introducing a std::min discontinuity.
        using std::abs;
        const auto a1 = abs(du_1), a2 = abs(du_2);
        const auto min_a = NumberType(0.5) * (a1 + a2 - abs_with_zero_tie_derivative(a1 - a2));
        return NumberType(0.5) * (limiter_utils::sgn(du_1) + limiter_utils::sgn(du_2)) * min_a;
      }
    };
    static_assert(HasSlopeLimiter<MinModLimiter>);
 
  } // namespace def
} // namespace DiFfRG