Intrepid2_Utils.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Intrepid2 Package
//
// Copyright 2007 NTESS and the Intrepid2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __INTREPID2_UTILS_HPP__
#define __INTREPID2_UTILS_HPP__
 
#include "Intrepid2_ConfigDefs.hpp"
#include "Intrepid2_DeviceAssert.hpp"
#include "Intrepid2_Types.hpp"
 
#include "Kokkos_Core.hpp"
#include "Kokkos_Macros.hpp" // provides some preprocessor values used in definitions of INTREPID2_DEPRECATED, etc.
#include "Kokkos_Random.hpp"
 
#ifdef HAVE_INTREPID2_SACADO
#include "Sacado_Fad_Kokkos_Fwd.hpp"
#include "Sacado_Fad_Kokkos_ViewFactory.hpp"
#endif
 
namespace Intrepid2 {
 
#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__) || defined(__SYCL_DEVICE_ONLY__)
#define INTREPID2_COMPILE_DEVICE_CODE
#endif
 
#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) || defined(KOKKOS_ENABLE_SYCL)
#define INTREPID2_ENABLE_DEVICE
#endif
 
#if defined(KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION) \
  && defined(KOKKOS_ENABLE_PRAGMA_IVDEP) \
  && !defined(INTREPID2_COMPILE_DEVICE_CODE)
#define INTREPID2_USE_IVDEP
#endif
 
  //
  // test macros
  //
 
#define INTREPID2_TEST_FOR_WARNING(test, msg)                           \
  if (test) {                                                           \
    Kokkos::printf("[Intrepid2] Warning in file %s, line %d\n",__FILE__,__LINE__); \
    Kokkos::printf("            Test that evaluated to true: %s\n", #test);     \
    Kokkos::printf("            %s \n", msg);                                   \
  }
 
#define INTREPID2_TEST_FOR_EXCEPTION(test, x, msg)                      \
  if (test) {                                                           \
    Kokkos::printf("[Intrepid2] Error in file %s, line %d\n",__FILE__,__LINE__); \
    Kokkos::printf("            Test that evaluated to true: %s\n", #test);     \
    Kokkos::printf("            %s \n", msg);                                   \
    throw x(msg);                                                       \
  }
 
#ifndef INTREPID2_ENABLE_DEVICE
#define INTREPID2_TEST_FOR_EXCEPTION_DEVICE_SAFE(test, x, msg)                              \
  if (test) {                                                                               \
    std::cout << "[Intrepid2] Error in file " << __FILE__ << ", line " << __LINE__ << "\n"; \
    std::cout << "            Test that evaluated to true: " << #test << "\n";              \
    std::cout << "            " << msg << " \n";                                            \
    throw x(msg);                                                                           \
  }
#else
#define INTREPID2_TEST_FOR_EXCEPTION_DEVICE_SAFE(test, x, msg)          \
  if (test) {                                                           \
    Kokkos::printf("[Intrepid2] Error in file %s, line %d\n",__FILE__,__LINE__); \
    Kokkos::printf("            Test that evaluated to true: %s\n", #test);     \
    Kokkos::printf("            %s \n", msg);                                   \
    Kokkos::abort(  "[Intrepid2] Abort\n");                             \
  }
#endif
#if defined(INTREPID2_ENABLE_DEBUG) || defined(NDEBUG) || 1
#define INTREPID2_TEST_FOR_ABORT(test, msg)                             \
  if (test) {                                                           \
    Kokkos::printf("[Intrepid2] Error in file %s, line %d\n",__FILE__,__LINE__); \
    Kokkos::printf("            Test that evaluated to true: %s\n", #test);     \
    Kokkos::printf("            %s \n", msg);                                   \
    Kokkos::abort(  "[Intrepid2] Abort\n");                             \
  }
#else
#define INTREPID2_TEST_FOR_ABORT(test, msg) ((void)0)      
#endif
  // check the first error only
#ifdef INTREPID2_TEST_FOR_DEBUG_ABORT_OVERRIDE_TO_CONTINUE
#define INTREPID2_TEST_FOR_DEBUG_ABORT(test, info, msg)                 \
  if (!(info) && (test)) {                                              \
    Kokkos::printf("[Intrepid2] Error in file %s, line %d\n",__FILE__,__LINE__); \
    Kokkos::printf("            Test that evaluated to true: %s\n", #test);     \
    Kokkos::printf("            %s \n", msg);                                   \
    info = true;                                                        \
  }
#else  
#define INTREPID2_TEST_FOR_DEBUG_ABORT(test, info, msg)                 \
  if (!(info) && (test)) {                                              \
    Kokkos::printf("[Intrepid2] Error in file %s, line %d\n",__FILE__,__LINE__); \
    Kokkos::printf("            Test that evaluated to true: %s\n", #test);     \
    Kokkos::printf("            %s \n", msg);                                   \
    info = true ;                                                       \
    Kokkos::abort(  "[Intrepid2] Abort\n");                             \
  }
#endif
 
  template<typename T> 
  struct ScalarTraits {
    typedef typename T::scalar_type scalar_type;
  };
 
  // this is built in types to support
  template<>
  struct ScalarTraits<float> {
    typedef float scalar_type;
  };
  template<>
  struct ScalarTraits<double> {
    typedef double scalar_type;
  };
  template<>
  struct ScalarTraits<int> {
    typedef int scalar_type;
  };
  template<>
  struct ScalarTraits<long int> {
    typedef long int scalar_type;
  };
  template<>
  struct ScalarTraits<long long> {
    typedef long long scalar_type;
  };
 
 
 
  template<typename ViewSpaceType, typename UserSpaceType>
  struct ExecSpace {
    typedef UserSpaceType ExecSpaceType;
  };
 
  template<typename ViewSpaceType>
  struct ExecSpace<ViewSpaceType,void> {
    typedef ViewSpaceType ExecSpaceType;
  };
 
 
  template <typename ViewType>
  struct DeduceLayout {
    using input_layout = typename ViewType::array_layout;
    using default_layout = typename ViewType::device_type::execution_space::array_layout;
    using result_layout  =
      typename std::conditional<
        std::is_same< input_layout, Kokkos::LayoutStride >::value,
        default_layout,
        input_layout >::type;
  };
 
 
  //
  // utilities device comparible
  //
 
  // this will be gone 
  template<typename IdxType, typename DimType, typename IterType>
  KOKKOS_FORCEINLINE_FUNCTION
  static void 
  unrollIndex(IdxType &i, IdxType &j, 
              const DimType /* dim0 */,
              const DimType dim1,
              const IterType iter) {
    // left index
    //j = iter/dim0;
    //i = iter%dim0;
    
    // right index
    i = iter/dim1;
    j = iter%dim1;
  }
  
  template<typename IdxType, typename DimType, typename IterType>
  KOKKOS_FORCEINLINE_FUNCTION
  static void 
  unrollIndex(IdxType &i, IdxType &j, IdxType &k, 
              const DimType dim0,
              const DimType dim1,
              const DimType dim2,
              const IterType iter) {
    IdxType tmp;
    
    //unrollIndex(tmp, k, dim0*dim1, dim2, iter);
    //unrollIndex(  i, j, dim0,      dim1,  tmp);
    
    unrollIndex( i, tmp, dim0, dim1*dim2, iter);
    unrollIndex( j, k,   dim1,      dim2,  tmp);
  }
  
  template<typename T>
  class Util {
  public:
    KOKKOS_FORCEINLINE_FUNCTION
    static T min(const T a, const T b) {
      return (a < b ? a : b);
    }
 
    KOKKOS_FORCEINLINE_FUNCTION
    static T max(const T a, const T b) {
      return (a > b ? a : b);
    }
 
    template <typename... Args>
    requires (std::is_same_v<T, Args> && ...)
    KOKKOS_FORCEINLINE_FUNCTION
    static T max(const T a, const T b, Args... args) {
        // Recursively find the max of everything after the first argument
        T tmp_max = max(b, args...);
        return (a > tmp_max) ? a : tmp_max;
    }
 
    KOKKOS_FORCEINLINE_FUNCTION
    static T abs(const T a) {
      return (a > 0 ? a : T(-a));
    }
 
  };
 
  template<typename T>
  KOKKOS_FORCEINLINE_FUNCTION
  static T min(const T &a, const T &b) {
    return (a < b ? a : b);
  }
 
  template<typename T>
  KOKKOS_FORCEINLINE_FUNCTION
  static T max(const T &a, const T &b) {
    return (a > b ? a : b);
  }
 
  template<typename T>
  KOKKOS_FORCEINLINE_FUNCTION
  static T abs(const T &a) {
    return (a > 0 ? a : T(-a));
  }
 
  template<typename T>
  KOKKOS_FORCEINLINE_FUNCTION
  constexpr typename
  std::enable_if< !(std::is_standard_layout<T>::value && std::is_trivial<T>::value), typename ScalarTraits<T>::scalar_type >::type
  get_scalar_value(const T& obj) {return obj.val();}
 
  template<typename T>
  KOKKOS_FORCEINLINE_FUNCTION
  constexpr typename
  std::enable_if< std::is_standard_layout<T>::value && std::is_trivial<T>::value, typename ScalarTraits<T>::scalar_type >::type
  get_scalar_value(const T& obj){return obj;}
 
 
  // These should not be needed anymore as the Sacado implementation of dimension_scalar should handle this, so commenting out
 
  // template<typename T, typename ...P>
  // KOKKOS_INLINE_FUNCTION
  // constexpr typename
  // std::enable_if< std::is_standard_layout<T>::value && std::is_trivial<T>::value, unsigned >::type
  // dimension_scalar(const Kokkos::DynRankView<T, P...> /* view */) {return 1;}
 
  // template<typename T, typename ...P>
  // KOKKOS_INLINE_FUNCTION
  // constexpr typename
  // std::enable_if< std::is_standard_layout<typename Kokkos::View<T, P...>::value_type>::value && std::is_trivial<typename Kokkos::View<T, P...>::value_type>::value, unsigned >::type
  // dimension_scalar(const Kokkos::View<T, P...> /*view*/) {return 1;}
 
  template<typename T, typename ...P>
  KOKKOS_FORCEINLINE_FUNCTION
  static ordinal_type get_dimension_scalar(const Kokkos::DynRankView<T, P...> &view) {
    return Sacado::dimension_scalar(view);
  }
 
  template<typename T, typename ...P>
  KOKKOS_FORCEINLINE_FUNCTION
  static ordinal_type get_dimension_scalar(const Kokkos::View<T, P...> &view) {
    return Sacado::dimension_scalar(view);
  }
 
  // such that the ouptut view type has the default layout when the input has LayoutStride
  template <typename InputView>
  struct DeduceDynRankView
  {
    using value = typename InputView::non_const_value_type;
    using layout = typename DeduceLayout<InputView>::result_layout;
    using device = typename InputView::device_type;
    using type = Kokkos::DynRankView<value, layout, device>;
  };
 
 
  template <class DataType, class... Properties>
  KOKKOS_INLINE_FUNCTION auto
  as_scalar_1d_view(const Kokkos::View<DataType, Properties...> &view) {
    using view_t = Kokkos::View<DataType, Properties...>;
#ifdef HAVE_INTREPID2_SACADO
    if constexpr (Sacado::is_view_fad<view_t>::value) {
      return Sacado::as_scalar_view(view);
    } else
#endif
    return Kokkos::View<typename view_t::value_type*, Properties...>(view.data(), view.mapping().required_span_size());
  }
 
  template <class... Args>
  KOKKOS_INLINE_FUNCTION auto
  as_scalar_1d_view(const Kokkos::DynRankView<Args...> &dyn) {
    return as_scalar_1d_view(dyn.ConstDownCast());
  }
 
 
  namespace Impl
  {
    template <class... ViewPack>
    struct CreateViewFactory
    {
      template <class OutViewType, class CtorProp, class... Dims>
      static OutViewType
      create_view(const ViewPack &...views,
                  const CtorProp &prop,
                  const Dims... dims)
      {
  #ifdef HAVE_INTREPID2_SACADO
        using view_factory = Sacado::ViewFactory<ViewPack...>;
        return view_factory::template create_view<OutViewType>(views..., prop, dims...);
  #else
        ((void)views, ...);
        return OutViewType(prop, dims...);
  #endif
      }
    };
 
    template <typename OutViewType, typename InViewType, typename CtorProp, typename... Dims>
    OutViewType
    createMatchingView(const InViewType &view,
                              const CtorProp &prop,
                              const Dims... dims)
    {
      using cvf = CreateViewFactory<InViewType>;
      return cvf::template create_view<OutViewType>(view, prop, dims...);
    }
 
    template <typename InViewType, typename CtorProp, typename... Dims>
    typename DeduceDynRankView<InViewType>::type
    createMatchingDynRankView(const InViewType &view,
                              const CtorProp &prop,
                              const Dims... dims)
    {
      using OutViewType = typename DeduceDynRankView<InViewType>::type;
      return createMatchingView<OutViewType>(view, prop, dims...);
    }
 
    template <typename OutViewType, typename InViewType, typename CtorProp, typename... Dims>
    KOKKOS_INLINE_FUNCTION
    typename std::enable_if<
    std::is_pointer_v<CtorProp> && !std::is_convertible_v<CtorProp, const char*>,
    OutViewType>::type
    createMatchingUnmanagedView(const InViewType &view, const CtorProp &data, const Dims... dims)
    {
  #ifdef HAVE_INTREPID2_SACADO
      if constexpr (Sacado::is_view_fad<InViewType>::value)
      {
        const int derivative_dimension = get_dimension_scalar(view);
        return OutViewType(data, dims..., derivative_dimension);
      }
      else
        return OutViewType(data, dims...);
  #else
      (void)view;
      return OutViewType(data, dims...);
  #endif
    }
 
    template <typename InViewType, typename CtorProp, typename ... Dims>
    KOKKOS_INLINE_FUNCTION
    typename std::enable_if<
    std::is_pointer_v<CtorProp> && !std::is_convertible_v<CtorProp, const char*>,
    typename DeduceDynRankView<InViewType>::type>::type
    createMatchingUnmanagedDynRankView(const InViewType& view, const CtorProp&  data, const Dims... dims){
        using OutViewType = typename DeduceDynRankView<InViewType>::type;
        return createMatchingUnmanagedView<OutViewType>(view, data, dims...);
    }
 
  } //Impl namespace
 
  
  template<class ViewType, class ... DimArgs>
  inline
  Kokkos::DynRankView<typename ViewType::value_type, typename DeduceLayout< ViewType >::result_layout, typename ViewType::device_type >
  getMatchingViewWithLabel(const ViewType &view, const std::string &label, DimArgs... dims)
  {
    return Impl::createMatchingDynRankView(view, label, dims...);
  }
 
  using std::enable_if_t;
 
  template <typename T, typename = void>
  struct has_rank_member : std::false_type{};
 
  template <typename T>
  struct has_rank_member<T, decltype((void)T::rank, void())> : std::true_type {};
 
  static_assert(! has_rank_member<Kokkos::DynRankView<double> >::value, "DynRankView does not have a member rank, so this assert should pass -- if not, something may be wrong with has_rank_member.");
 
  template<class Functor, ordinal_type default_value>
  constexpr
  enable_if_t<has_rank_member<Functor>::value, ordinal_type>
  getFixedRank()
  {
    return Functor::rank;
  }
 
  template<class Functor, ordinal_type default_value>
  constexpr
  enable_if_t<!has_rank_member<Functor>::value, ordinal_type>
  getFixedRank()
  {
    return default_value;
  }
 
  template <typename T>
  class supports_rank_1
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0))>::type );
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) && (getFixedRank<T,1>() == 1)  };
  };
 
  template <typename T>
  class supports_rank_2
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0,0))>::type ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) && (getFixedRank<T,2>() == 2)  };
  };
 
  template <typename T>
  class supports_rank_3
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0,0,0))>::type ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = (sizeof(test<T>(0)) == sizeof(char)) && (getFixedRank<T,3>() == 3) };
  };
 
  template <typename T>
  class supports_rank_4
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0,0,0,0))>::type ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) && (getFixedRank<T,4>() == 4)  };
  };
 
  template <typename T>
  class supports_rank_5
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0,0,0,0,0))>::type ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) && (getFixedRank<T,5>() == 5) };
  };
 
  template <typename T>
  class supports_rank_6
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0,0,0,0,0,0))>::type ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) && (getFixedRank<T,6>() == 6)  };
  };
 
  template <typename T>
  class supports_rank_7
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( typename std::remove_reference<decltype( std::declval<C>().operator()(0,0,0,0,0,0,0))>::type ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) && (getFixedRank<T,7>() == 7) };
  };
 
  template <typename T, int rank>
  class supports_rank
  {
  public:
      enum { value = false };
  };
 
  template <typename T>
  class supports_rank<T,1>
  {
  public:
      enum { value = supports_rank_1<T>::value };
  };
 
  template <typename T>
  class supports_rank<T,2>
  {
  public:
      enum { value = supports_rank_2<T>::value };
  };
 
  template <typename T>
  class supports_rank<T,3>
  {
  public:
      enum { value = supports_rank_3<T>::value };
  };
 
  template <typename T>
  class supports_rank<T,4>
  {
  public:
      enum { value = supports_rank_4<T>::value };
  };
 
  template <typename T>
  class supports_rank<T,5>
  {
  public:
      enum { value = supports_rank_5<T>::value };
  };
 
  template <typename T>
  class supports_rank<T,6>
  {
  public:
      enum { value = supports_rank_6<T>::value };
  };
 
  template <typename T>
  class supports_rank<T,7>
  {
  public:
      enum { value = supports_rank_7<T>::value };
  };
 
 
 
  template<typename Scalar, int rank>
  struct RankExpander {
    
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,0>
  {
    using value_type = Scalar;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,1>
  {
    using value_type = Scalar*;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,2>
  {
    using value_type = Scalar**;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,3>
  {
    using value_type = Scalar***;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,4>
  {
    using value_type = Scalar****;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,5>
  {
    using value_type = Scalar*****;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,6>
  {
    using value_type = Scalar******;
  };
 
  template<typename Scalar>
  struct RankExpander<Scalar,7>
  {
    using value_type = Scalar*******;
  };
 
  // positive checks of supports_rank for Kokkos::DynRankView:
  static_assert(supports_rank<Kokkos::DynRankView<double>, 1>::value, "rank 1 check of supports_rank for DynRankView");
  static_assert(supports_rank<Kokkos::DynRankView<double>, 2>::value, "rank 2 check of supports_rank for DynRankView");
  static_assert(supports_rank<Kokkos::DynRankView<double>, 3>::value, "rank 3 check of supports_rank for DynRankView");
  static_assert(supports_rank<Kokkos::DynRankView<double>, 4>::value, "rank 4 check of supports_rank for DynRankView");
  static_assert(supports_rank<Kokkos::DynRankView<double>, 5>::value, "rank 5 check of supports_rank for DynRankView");
  static_assert(supports_rank<Kokkos::DynRankView<double>, 6>::value, "rank 6 check of supports_rank for DynRankView");
  static_assert(supports_rank<Kokkos::DynRankView<double>, 7>::value, "rank 7 check of supports_rank for DynRankView");
 
  // positive checks of supports_rank for Kokkos::View:
  static_assert(supports_rank<Kokkos::View<double*>,       1>::value, "rank 1 check of supports_rank");
  static_assert(supports_rank<Kokkos::View<double**>,      2>::value, "rank 2 check of supports_rank");
  static_assert(supports_rank<Kokkos::View<double***>,     3>::value, "rank 3 check of supports_rank");
  static_assert(supports_rank<Kokkos::View<double****>,    4>::value, "rank 4 check of supports_rank");
  static_assert(supports_rank<Kokkos::View<double*****>,   5>::value, "rank 5 check of supports_rank");
  static_assert(supports_rank<Kokkos::View<double******>,  6>::value, "rank 6 check of supports_rank");
  static_assert(supports_rank<Kokkos::View<double*******>, 7>::value, "rank 7 check of supports_rank");
 
  // negative checks of supports_rank for Kokkos::View:
  static_assert(!supports_rank<Kokkos::View<double*>,       2>::value, "rank 1 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*>,       3>::value, "rank 1 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*>,       4>::value, "rank 1 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*>,       5>::value, "rank 1 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*>,       6>::value, "rank 1 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*>,       7>::value, "rank 1 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double**>,      1>::value, "rank 2 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double**>,      3>::value, "rank 2 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double**>,      4>::value, "rank 2 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double**>,      5>::value, "rank 2 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double**>,      6>::value, "rank 2 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double**>,      7>::value, "rank 2 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double***>,     1>::value, "rank 3 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double***>,     2>::value, "rank 3 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double***>,     4>::value, "rank 3 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double***>,     5>::value, "rank 3 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double***>,     6>::value, "rank 3 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double***>,     7>::value, "rank 3 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double****>,    1>::value, "rank 4 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double****>,    2>::value, "rank 4 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double****>,    3>::value, "rank 4 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double****>,    5>::value, "rank 4 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double****>,    6>::value, "rank 4 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double****>,    7>::value, "rank 4 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*****>,   1>::value, "rank 5 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*****>,   2>::value, "rank 5 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*****>,   3>::value, "rank 5 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*****>,   4>::value, "rank 5 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*****>,   6>::value, "rank 5 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*****>,   7>::value, "rank 5 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double******>,  1>::value, "rank 6 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double******>,  2>::value, "rank 6 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double******>,  3>::value, "rank 6 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double******>,  4>::value, "rank 6 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double******>,  5>::value, "rank 6 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double******>,  7>::value, "rank 6 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*******>, 1>::value, "rank 7 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*******>, 2>::value, "rank 7 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*******>, 3>::value, "rank 7 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*******>, 4>::value, "rank 7 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*******>, 5>::value, "rank 7 check of supports_rank");
  static_assert(!supports_rank<Kokkos::View<double*******>, 6>::value, "rank 7 check of supports_rank");
 
  template <typename T>
  class has_rank_method
  {
      typedef char one;
      struct two { char x[2]; };
 
      template <typename C> static one test( decltype( std::declval<C>().rank()  ) ) ;
      template <typename C> static two test(...);
 
  public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) };
  };
 
  static_assert(  has_rank_method<Kokkos::DynRankView<double> >::value, "DynRankView implements rank(), so this assert should pass -- if not, something may be wrong with has_rank_method.");
 
  template<class Functor>
  enable_if_t<has_rank_method<Functor>::value, unsigned>
  KOKKOS_INLINE_FUNCTION
  getFunctorRank(const Functor &functor)
  {
    return functor.rank();
  }
 
  template<class Functor>
  enable_if_t<!has_rank_method<Functor>::value, unsigned>
  KOKKOS_INLINE_FUNCTION
  getFunctorRank(const Functor &functor)
  {
    return functor.rank;
  }
 
  template <typename ValueType>
  struct NaturalLayoutForType {
    using layout  = Kokkos::LayoutLeft;
  };
  
  // define vector sizes for hierarchical parallelism
  const int VECTOR_SIZE = 1;
#if defined(SACADO_VIEW_CUDA_HIERARCHICAL_DFAD) && defined(INTREPID2_ENABLE_DEVICE)
  const int FAD_VECTOR_SIZE = 32;
#else
  const int FAD_VECTOR_SIZE = 1;
#endif
  
  template<typename Scalar>
  constexpr int getVectorSizeForHierarchicalParallelism()
  {
    return (std::is_standard_layout<Scalar>::value && std::is_trivial<Scalar>::value) ? VECTOR_SIZE : FAD_VECTOR_SIZE;
  }
  
  template<typename ViewType>
  KOKKOS_INLINE_FUNCTION
  constexpr unsigned getScalarDimensionForView(const ViewType &view)
  {
    return (std::is_standard_layout<typename ViewType::value_type>::value && std::is_trivial<typename ViewType::value_type>::value) ? 0 : get_dimension_scalar(view);
  }
 
  template<typename Device>
  struct DeviceDeleter {
    template<typename T>
    void operator()(T* ptr) {
      Kokkos::parallel_for(Kokkos::RangePolicy<typename Device::execution_space>(0,1),
                           KOKKOS_LAMBDA (const int i) { ptr->~T(); });
      typename Device::execution_space().fence();
      Kokkos::kokkos_free<typename Device::memory_space>(ptr);
    }
  };
 
  template<typename Device,typename Derived>
  std::unique_ptr<Derived,DeviceDeleter<Device>>
  copy_virtual_class_to_device(const Derived& host_source)
  {
    auto* p = static_cast<Derived*>(Kokkos::kokkos_malloc<typename Device::memory_space>(sizeof(Derived)));
    Kokkos::parallel_for(Kokkos::RangePolicy<typename Device::execution_space>(0,1),
                         KOKKOS_LAMBDA (const int i) {new (p) Derived(host_source); });
    typename Device::execution_space().fence();
    return std::unique_ptr<Derived,DeviceDeleter<Device>>(p);
  }
 
 
 
 
 
 
 
 
} // end namespace Intrepid2
 
#endif