convenience_macros.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: MIT
// Copyright (C) 2020 - 2023 by the ryujin authors
//
 
#pragma once
 
#include <deal.II/base/function.h>
 
 
namespace ryujin
{
#ifndef DOXYGEN
  namespace
  {
    template <int dim, typename Number, typename Callable>
    class ToFunction : public dealii::Function<dim, Number>
    {
    public:
      ToFunction(const Callable &callable, const unsigned int k)
          : dealii::Function<dim, Number>(1)
          , callable_(callable)
          , k_(k)
      {
      }
 
      Number value(const dealii::Point<dim> &point,
                   unsigned int /*component*/) const override
      {
        return callable_(point)[k_];
      }
 
    private:
      const Callable callable_;
      const unsigned int k_;
    };
  } // namespace
#endif
 
 
  template <int dim, typename Number, typename Callable>
  ToFunction<dim, Number, Callable> to_function(const Callable &callable,
                                                const unsigned int k)
  {
    return {callable, k};
  }
 
 
  template <typename FT,
            int problem_dim = FT::dimension,
            typename TT = typename FT::value_type,
            typename T = typename TT::value_type>
  DEAL_II_ALWAYS_INLINE inline dealii::Tensor<1, problem_dim, T>
  contract(const FT &flux_ij, const TT &c_ij)
  {
    dealii::Tensor<1, problem_dim, T> result;
    for (unsigned int k = 0; k < problem_dim; ++k)
      result[k] = flux_ij[k] * c_ij;
    return result;
  }
 
 
  template <typename FT, int problem_dim = FT::dimension>
  DEAL_II_ALWAYS_INLINE inline FT add(const FT &flux_left_ij,
                                      const FT &flux_right_ij)
  {
    FT result;
    for (unsigned int k = 0; k < problem_dim; ++k)
      result[k] = flux_left_ij[k] + flux_right_ij[k];
    return result;
  }
 
 
} // namespace ryujin
 
 
#define AssertThrowSIMD(variable, condition, exception)                        \
  if constexpr (std::is_same<                                                  \
                    typename std::remove_const<decltype(variable)>::type,      \
                    double>::value ||                                          \
                std::is_same<                                                  \
                    typename std::remove_const<decltype(variable)>::type,      \
                    float>::value) {                                           \
    AssertThrow(condition(variable), exception);                               \
  } else {                                                                     \
    for (unsigned int k = 0; k < decltype(variable)::size(); ++k) {            \
      AssertThrow(condition((variable)[k]), exception);                        \
    }                                                                          \
  }
 
#ifndef DOXYGEN
namespace
{
  template <typename T>
  class is_dereferenceable
  {
    template <typename C>
    static auto test(...) -> std::false_type;
 
    template <typename C>
    static auto test(C *) -> decltype(*std::declval<C>(), std::true_type());
 
  public:
    using type = decltype(test<T>(nullptr));
    static constexpr auto value = type::value;
  };
 
  template <typename T, typename>
  auto dereference(T &t) -> decltype(dereference(*t)) &;
 
  template <
      typename T,
      typename = typename std::enable_if<!is_dereferenceable<T>::value>::type>
  auto dereference(T &t) -> T &
  {
    return t;
  }
 
  template <
      typename T,
      typename = typename std::enable_if<is_dereferenceable<T>::value>::type>
  auto dereference(T &t) -> decltype(*t) &
  {
    return *t;
  }
} /* anonymous namespace */
#endif
 
#define ACCESSOR_READ_ONLY(member)                                             \
  inline auto &member() const                                                  \
  {                                                                            \
    return dereference(member##_);                                             \
  }
 
 
#define ACCESSOR(member)                                                       \
  inline auto &member()                                                        \
  {                                                                            \
    return dereference(member##_);                                             \
  }
 
 
#define ACCESSOR_READ_ONLY_NO_DEREFERENCE(member)                              \
  inline const auto &member() const                                            \
  {                                                                            \
    return member##_;                                                          \
  }
 
 
#define ASM_LABEL(label) asm("#" label);