Updates after review with Peter.

Grid/simd/Grid_vector_types.h

@@ -10,6 +10,7 @@ Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Guido Cossu <cossu@iroiro-pc.kek.jp>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: neo <cossu@post.kek.jp>
+Author: Michael Marshall <michael.marshall@ed.ac.au>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -865,8 +866,10 @@ template <typename T>
 struct is_simd : public std::false_type {};
 template <> struct is_simd<vRealF>     : public std::true_type {};
 template <> struct is_simd<vRealD>     : public std::true_type {};
+template <> struct is_simd<vRealH>     : public std::true_type {};
 template <> struct is_simd<vComplexF>  : public std::true_type {};
 template <> struct is_simd<vComplexD>  : public std::true_type {};
+template <> struct is_simd<vComplexH>  : public std::true_type {};
 template <> struct is_simd<vInteger>   : public std::true_type {};
 
 template <typename T> using IfSimd    = Invoke<std::enable_if<is_simd<T>::value, int> >;

Grid/tensors/Tensor_class.h

@@ -5,6 +5,7 @@ Copyright (C) 2015
 
 Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: Michael Marshall <michael.marshall@ed.ac.au>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -42,27 +43,26 @@ namespace Grid {
 //
 class GridTensorBase {};
 
+// Too late to remove these traits from Grid Tensors, so inherit from GridTypeMapper
+#define GridVector_CopyTraits \
+  using element = vtype; \
+  using scalar_type     = typename Traits::scalar_type; \
+  using vector_type     = typename Traits::vector_type; \
+  using vector_typeD    = typename Traits::vector_typeD; \
+  using tensor_reduced  = typename Traits::tensor_reduced; \
+  using scalar_object   = typename Traits::scalar_object; \
+  using Complexified    = typename Traits::Complexified; \
+  using Realified       = typename Traits::Realified; \
+  using DoublePrecision = typename Traits::DoublePrecision; \
+  static constexpr int TensorLevel = Traits::TensorLevel
+
 template <class vtype>
 class iScalar {
  public:
   vtype _internal;
 
-  typedef vtype element;
+  using Traits = GridTypeMapper<iScalar<vtype> >;
-  typedef typename GridTypeMapper<vtype>::scalar_type scalar_type;
+  GridVector_CopyTraits;
-  typedef typename GridTypeMapper<vtype>::vector_type vector_type;
-  typedef typename GridTypeMapper<vtype>::vector_typeD vector_typeD;
-  typedef typename GridTypeMapper<vtype>::tensor_reduced tensor_reduced_v;
-  typedef typename GridTypeMapper<vtype>::scalar_object recurse_scalar_object;
-  typedef iScalar<tensor_reduced_v> tensor_reduced;
-  typedef iScalar<recurse_scalar_object> scalar_object;
-  // substitutes a real or complex version with same tensor structure
-  typedef iScalar<typename GridTypeMapper<vtype>::Complexified> Complexified;
-  typedef iScalar<typename GridTypeMapper<vtype>::Realified> Realified;
-
-  // get double precision version
-  typedef iScalar<typename GridTypeMapper<vtype>::DoublePrecision> DoublePrecision;
-  
-  static constexpr int TensorLevel = GridTypeMapper<vtype>::TensorLevel + 1;
 
   // Scalar no action
   //  template<int Level> using tensor_reduce_level = typename
@@ -173,37 +173,10 @@ class iScalar {
     return stream;
   };
 
-  template <typename T = vtype>
+  strong_inline const scalar_type * begin() const { return reinterpret_cast<const scalar_type *>(&_internal); }
-  typename std::enable_if<!isGridTensor<T>::value, const scalar_type *>::type
+  strong_inline       scalar_type * begin()       { return reinterpret_cast<      scalar_type *>(&_internal); }
-  strong_inline begin() const { return &_internal; }
+  strong_inline const scalar_type * end()   const { return begin() + Traits::count; }
-
+  strong_inline       scalar_type * end()         { return begin() + Traits::count; }
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline begin() const { return _internal.begin(); }
-
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline end() const { return (&_internal) + 1; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline end() const { return _internal.begin() + sizeof(_internal)/sizeof(scalar_type); }
-
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, scalar_type *>::type
-  strong_inline begin() { return &_internal; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, scalar_type *>::type
-  strong_inline begin() { return _internal.begin(); }
-  
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, scalar_type *>::type
-  strong_inline end() { return (&_internal) + 1; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, scalar_type *>::type
-  strong_inline end() { return _internal.begin() + sizeof(_internal)/sizeof(scalar_type); }
 };
 ///////////////////////////////////////////////////////////
 // Allows to turn scalar<scalar<scalar<double>>>> back to double.
@@ -224,22 +197,9 @@ class iVector {
  public:
   vtype _internal[N];
 
-  typedef vtype element;
+  using Traits = GridTypeMapper<iVector<vtype, N> >;
-  typedef typename GridTypeMapper<vtype>::scalar_type scalar_type;
+  GridVector_CopyTraits;
-  typedef typename GridTypeMapper<vtype>::vector_type vector_type;
-  typedef typename GridTypeMapper<vtype>::vector_typeD vector_typeD;
-  typedef typename GridTypeMapper<vtype>::tensor_reduced tensor_reduced_v;
-  typedef typename GridTypeMapper<vtype>::scalar_object recurse_scalar_object;
-  typedef iScalar<tensor_reduced_v> tensor_reduced;
-  typedef iVector<recurse_scalar_object, N> scalar_object;
 
-  // substitutes a real or complex version with same tensor structure
-  typedef iVector<typename GridTypeMapper<vtype>::Complexified, N> Complexified;
-  typedef iVector<typename GridTypeMapper<vtype>::Realified, N> Realified;
-
-  // get double precision version
-  typedef iVector<typename GridTypeMapper<vtype>::DoublePrecision, N> DoublePrecision;
-  
   template <class T, typename std::enable_if<!isGridTensor<T>::value, T>::type
                          * = nullptr>
   strong_inline auto operator=(T arg) -> iVector<vtype, N> {
@@ -248,7 +208,6 @@ class iVector {
     return *this;
   }
 
-  static constexpr int TensorLevel = GridTypeMapper<vtype>::TensorLevel + 1;
   iVector(const Zero &z) { *this = zero; };
   iVector() = default;
   /*
@@ -334,37 +293,10 @@ class iVector {
   //      return _internal[i];
   //    }
 
-  template <typename T = vtype>
+  strong_inline const scalar_type * begin() const { return reinterpret_cast<const scalar_type *>(_internal); }
-  typename std::enable_if<!isGridTensor<T>::value, const scalar_type *>::type
+  strong_inline       scalar_type * begin()       { return reinterpret_cast<      scalar_type *>(_internal); }
-  strong_inline begin() const { return _internal; }
+  strong_inline const scalar_type * end()   const { return begin() + Traits::count; }
-  
+  strong_inline       scalar_type * end()         { return begin() + Traits::count; }
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline begin() const { return _internal[0].begin(); }
-  
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline end() const { return _internal + N; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline end() const { return _internal[0].begin() + sizeof(_internal)/sizeof(scalar_type); }
-
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, scalar_type *>::type
-  strong_inline begin() { return _internal; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, scalar_type *>::type
-  strong_inline begin() { return _internal[0].begin(); }
-  
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, scalar_type *>::type
-  strong_inline end() { return _internal + N; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, scalar_type *>::type
-  strong_inline end() { return _internal[0].begin() + sizeof(_internal)/sizeof(scalar_type); }
 };
 
 template <class vtype, int N>
@@ -372,25 +304,8 @@ class iMatrix {
  public:
   vtype _internal[N][N];
 
-  typedef vtype element;
+  using Traits = GridTypeMapper<iMatrix<vtype, N> >;
-  typedef typename GridTypeMapper<vtype>::scalar_type scalar_type;
+  GridVector_CopyTraits;
-  typedef typename GridTypeMapper<vtype>::vector_type vector_type;
-  typedef typename GridTypeMapper<vtype>::vector_typeD vector_typeD;
-  typedef typename GridTypeMapper<vtype>::tensor_reduced tensor_reduced_v;
-  typedef typename GridTypeMapper<vtype>::scalar_object recurse_scalar_object;
-
-  // substitutes a real or complex version with same tensor structure
-  typedef iMatrix<typename GridTypeMapper<vtype>::Complexified, N> Complexified;
-  typedef iMatrix<typename GridTypeMapper<vtype>::Realified, N> Realified;
-
-  // get double precision version
-  typedef iMatrix<typename GridTypeMapper<vtype>::DoublePrecision, N> DoublePrecision;
-  
-  // Tensor removal
-  typedef iScalar<tensor_reduced_v> tensor_reduced;
-  typedef iMatrix<recurse_scalar_object, N> scalar_object;
-
-  static constexpr int TensorLevel = GridTypeMapper<vtype>::TensorLevel + 1;
 
   iMatrix(const Zero &z) { *this = zero; };
   iMatrix() = default;
@@ -521,37 +436,10 @@ class iMatrix {
   //    return _internal[i][j];
   //  }
 
-  template <typename T = vtype>
+  strong_inline const scalar_type * begin() const { return reinterpret_cast<const scalar_type *>(_internal[0]); }
-  typename std::enable_if<!isGridTensor<T>::value, const scalar_type *>::type
+  strong_inline       scalar_type * begin()       { return reinterpret_cast<      scalar_type *>(_internal[0]); }
-  strong_inline begin() const { return _internal[0]; }
+  strong_inline const scalar_type * end()   const { return begin() + Traits::count; }
-  
+  strong_inline       scalar_type * end()         { return begin() + Traits::count; }
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline begin() const { return _internal[0][0].begin(); }
-  
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline end() const { return _internal[0] + N * N; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, const scalar_type *>::type
-  strong_inline end() const { return _internal[0][0].begin() + sizeof(_internal)/sizeof(scalar_type); }
-
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, scalar_type *>::type
-  strong_inline begin() { return _internal[0]; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, scalar_type *>::type
-  strong_inline begin() { return _internal[0][0].begin(); }
-  
-  template <typename T = vtype>
-  typename std::enable_if<!isGridTensor<T>::value, scalar_type *>::type
-  strong_inline end() { return _internal[0] + N * N; }
-  
-  template <typename T = vtype>
-  typename std::enable_if<isGridTensor<T>::value, scalar_type *>::type
-  strong_inline end() { return _internal[0][0].begin() + sizeof(_internal)/sizeof(scalar_type); }
 };
 
 template <class v>
@@ -574,6 +462,3 @@ void vprefetch(const iMatrix<v, N> &vv) {
 }
 }
 #endif
-
-
-

Grid/tensors/Tensor_traits.h

@@ -5,6 +5,7 @@
 Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: Christopher Kelly <ckelly@phys.columbia.edu>
+Author: Michael Marshall <michael.marshall@ed.ac.au>
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
@@ -32,14 +33,10 @@ namespace Grid {
   template<class T, int N> class iMatrix;
 
   // These are the Grid tensors
-  template<typename T> struct isGridTensor
+  template<typename T>     struct isGridTensor                : public std::false_type { static constexpr bool notvalue = true; };
-  : public std::false_type { static constexpr bool notvalue = true; };
+  template<class T>        struct isGridTensor<iScalar<T>>    : public std::true_type  { static constexpr bool notvalue = false; };
-  template<class T> struct isGridTensor<iScalar<T>>
+  template<class T, int N> struct isGridTensor<iVector<T, N>> : public std::true_type  { static constexpr bool notvalue = false; };
-  : public std::true_type { static constexpr bool notvalue = false; };
+  template<class T, int N> struct isGridTensor<iMatrix<T, N>> : public std::true_type  { static constexpr bool notvalue = false; };
-  template<class T, int N> struct isGridTensor<iVector<T, N>>
-  : public std::true_type { static constexpr bool notvalue = false; };
-  template<class T, int N> struct isGridTensor<iMatrix<T, N>>
-  : public std::true_type { static constexpr bool notvalue = false; };
 
 //////////////////////////////////////////////////////////////////////////////////
 // Want to recurse: GridTypeMapper<Matrix<vComplexD> >::scalar_type == ComplexD.
@@ -57,20 +54,15 @@ namespace Grid {
 //////////////////////////////////////////////////////////////////////////////////
 
   // This saves repeating common properties for supported Grid Scalar types
-  template<typename T, typename V=void> struct GridTypeMapper_Base {};
   // TensorLevel    How many nested grid tensors
   // Rank           Rank of the grid tensor
   // count          Total number of elements, i.e. product of dimensions
-  // scalar_size    Size of the underlying fundamental object (tensor_reduced) in bytes
-  // size           Total size of all elements in bytes
   // Dimension(dim) Size of dimension dim
-  template<typename T> struct GridTypeMapper_Base<T> {
+  struct GridTypeMapper_Base {
     static constexpr int TensorLevel = 0;
     static constexpr int Rank = 0;
     static constexpr std::size_t count = 1;
-    static constexpr std::size_t scalar_size = sizeof(T);
+    static constexpr int Dimension(int dim) { return 0; }
-    static constexpr std::size_t size = scalar_size * count;
-    static constexpr int Dimension(unsigned int dim) { return 0; }
   };
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -79,7 +71,7 @@ namespace Grid {
 
   template<typename T> struct GridTypeMapper {};
 
-  template<> struct GridTypeMapper<RealF> : public GridTypeMapper_Base<RealF> {
+  template<> struct GridTypeMapper<RealF> : public GridTypeMapper_Base {
     typedef RealF scalar_type;
     typedef RealF vector_type;
     typedef RealD vector_typeD;
@@ -89,7 +81,7 @@ namespace Grid {
     typedef RealF Realified;
     typedef RealD DoublePrecision;
   };
-  template<> struct GridTypeMapper<RealD> : public GridTypeMapper_Base<RealD> {
+  template<> struct GridTypeMapper<RealD> : public GridTypeMapper_Base {
     typedef RealD scalar_type;
     typedef RealD vector_type;
     typedef RealD vector_typeD;
@@ -99,7 +91,7 @@ namespace Grid {
     typedef RealD Realified;
     typedef RealD DoublePrecision;
   };
-  template<> struct GridTypeMapper<ComplexF> : public GridTypeMapper_Base<ComplexF> {
+  template<> struct GridTypeMapper<ComplexF> : public GridTypeMapper_Base {
     typedef ComplexF scalar_type;
     typedef ComplexF vector_type;
     typedef ComplexD vector_typeD;
@@ -109,7 +101,7 @@ namespace Grid {
     typedef RealF Realified;
     typedef ComplexD DoublePrecision;
   };
-  template<> struct GridTypeMapper<ComplexD> : public GridTypeMapper_Base<ComplexD> {
+  template<> struct GridTypeMapper<ComplexD> : public GridTypeMapper_Base {
     typedef ComplexD scalar_type;
     typedef ComplexD vector_type;
     typedef ComplexD vector_typeD;
@@ -119,7 +111,7 @@ namespace Grid {
     typedef RealD Realified;
     typedef ComplexD DoublePrecision;
   };
-  template<> struct GridTypeMapper<Integer> : public GridTypeMapper_Base<Integer> {
+  template<> struct GridTypeMapper<Integer> : public GridTypeMapper_Base {
     typedef Integer scalar_type;
     typedef Integer vector_type;
     typedef Integer vector_typeD;
@@ -130,7 +122,7 @@ namespace Grid {
     typedef void DoublePrecision;
   };
 
-  template<> struct GridTypeMapper<vRealF> : public GridTypeMapper_Base<vRealF> {
+  template<> struct GridTypeMapper<vRealF> : public GridTypeMapper_Base {
     typedef RealF  scalar_type;
     typedef vRealF vector_type;
     typedef vRealD vector_typeD;
@@ -140,7 +132,7 @@ namespace Grid {
     typedef vRealF Realified;
     typedef vRealD DoublePrecision;
   };
-  template<> struct GridTypeMapper<vRealD> : public GridTypeMapper_Base<vRealD> {
+  template<> struct GridTypeMapper<vRealD> : public GridTypeMapper_Base {
     typedef RealD  scalar_type;
     typedef vRealD vector_type;
     typedef vRealD vector_typeD;
@@ -150,7 +142,17 @@ namespace Grid {
     typedef vRealD Realified;
     typedef vRealD DoublePrecision;
   };
-  template<> struct GridTypeMapper<vComplexH> : public GridTypeMapper_Base<vComplexH> {
+  template<> struct GridTypeMapper<vRealH> : public GridTypeMapper_Base {
+    typedef RealF  scalar_type;
+    typedef vRealH vector_type;
+    typedef vRealD vector_typeD;
+    typedef vRealH tensor_reduced;
+    typedef RealF  scalar_object;
+    typedef vComplexH Complexified;
+    typedef vRealH Realified;
+    typedef vRealD DoublePrecision;
+  };
+  template<> struct GridTypeMapper<vComplexH> : public GridTypeMapper_Base {
     typedef ComplexF  scalar_type;
     typedef vComplexH vector_type;
     typedef vComplexD vector_typeD;
@@ -160,7 +162,7 @@ namespace Grid {
     typedef vRealH Realified;
     typedef vComplexD DoublePrecision;
   };
-  template<> struct GridTypeMapper<vComplexF> : public GridTypeMapper_Base<vComplexF> {
+  template<> struct GridTypeMapper<vComplexF> : public GridTypeMapper_Base {
     typedef ComplexF  scalar_type;
     typedef vComplexF vector_type;
     typedef vComplexD vector_typeD;
@@ -170,7 +172,7 @@ namespace Grid {
     typedef vRealF Realified;
     typedef vComplexD DoublePrecision;
   };
-  template<> struct GridTypeMapper<vComplexD> : public GridTypeMapper_Base<vComplexD> {
+  template<> struct GridTypeMapper<vComplexD> : public GridTypeMapper_Base {
     typedef ComplexD  scalar_type;
     typedef vComplexD vector_type;
     typedef vComplexD vector_typeD;
@@ -180,7 +182,7 @@ namespace Grid {
     typedef vRealD Realified;
     typedef vComplexD DoublePrecision;
   };
-  template<> struct GridTypeMapper<vInteger> : public GridTypeMapper_Base<vInteger> {
+  template<> struct GridTypeMapper<vInteger> : public GridTypeMapper_Base {
     typedef  Integer scalar_type;
     typedef vInteger vector_type;
     typedef vInteger vector_typeD;
@@ -192,46 +194,49 @@ namespace Grid {
   };
 
 #define GridTypeMapper_RepeatedTypes \
-  typedef typename ObjectTraits::scalar_type scalar_type; \
+  using BaseTraits   = GridTypeMapper<T>; \
-  typedef typename ObjectTraits::vector_type vector_type; \
+  using scalar_type  = typename BaseTraits::scalar_type; \
-  typedef typename ObjectTraits::vector_typeD vector_typeD; \
+  using vector_type  = typename BaseTraits::vector_type; \
-  typedef typename ObjectTraits::tensor_reduced tensor_reduced; \
+  using vector_typeD = typename BaseTraits::vector_typeD; \
-  typedef typename ObjectTraits::scalar_object scalar_object; \
+  static constexpr int TensorLevel = BaseTraits::TensorLevel + 1
-  typedef typename ObjectTraits::Complexified Complexified; \
-  typedef typename ObjectTraits::Realified Realified; \
-  typedef typename ObjectTraits::DoublePrecision DoublePrecision; \
-  static constexpr int TensorLevel = BaseTraits::TensorLevel + 1; \
-  static constexpr std::size_t scalar_size = BaseTraits::scalar_size; \
-  static constexpr std::size_t size = scalar_size * count
 
   template<typename T> struct GridTypeMapper<iScalar<T>> {
-    using ObjectTraits = iScalar<T>;
-    using BaseTraits = GridTypeMapper<T>;
-    static constexpr int Rank = 1 + BaseTraits::Rank;
-    static constexpr std::size_t count = 1 * BaseTraits::count;
-    static constexpr int Dimension(unsigned int dim) {
-      return ( dim == 0 ) ? 1 : BaseTraits::Dimension(dim - 1); }
     GridTypeMapper_RepeatedTypes;
+    using tensor_reduced  = iScalar<typename BaseTraits::tensor_reduced>;
+    using scalar_object   = iScalar<typename BaseTraits::scalar_object>;
+    using Complexified    = iScalar<typename BaseTraits::Complexified>;
+    using Realified       = iScalar<typename BaseTraits::Realified>;
+    using DoublePrecision = iScalar<typename BaseTraits::DoublePrecision>;
+    static constexpr int Rank = BaseTraits::Rank + 1;
+    static constexpr std::size_t count = BaseTraits::count;
+    static constexpr int Dimension(int dim) {
+      return ( dim == 0 ) ? 1 : BaseTraits::Dimension(dim - 1); }
   };
 
   template<typename T, int N> struct GridTypeMapper<iVector<T, N>> {
-    using ObjectTraits = iVector<T, N>;
-    using BaseTraits = GridTypeMapper<T>;
-    static constexpr int Rank = 1 + BaseTraits::Rank;
-    static constexpr std::size_t count = N * BaseTraits::count;
-    static constexpr int Dimension(unsigned int dim) {
-      return ( dim == 0 ) ? N : BaseTraits::Dimension(dim - 1); }
     GridTypeMapper_RepeatedTypes;
+    using tensor_reduced  = iScalar<typename BaseTraits::tensor_reduced>;
+    using scalar_object   = iVector<typename BaseTraits::scalar_object,   N>;
+    using Complexified    = iVector<typename BaseTraits::Complexified,    N>;
+    using Realified       = iVector<typename BaseTraits::Realified,       N>;
+    using DoublePrecision = iVector<typename BaseTraits::DoublePrecision, N>;
+    static constexpr int Rank = BaseTraits::Rank + 1;
+    static constexpr std::size_t count = BaseTraits::count * N;
+    static constexpr int Dimension(int dim) {
+      return ( dim == 0 ) ? N : BaseTraits::Dimension(dim - 1); }
   };
 
   template<typename T, int N> struct GridTypeMapper<iMatrix<T, N>> {
-    using ObjectTraits = iMatrix<T, N>;
-    using BaseTraits = GridTypeMapper<T>;
-    static constexpr int Rank = 2 + BaseTraits::Rank;
-    static constexpr std::size_t count = N * N * BaseTraits::count;
-    static constexpr int Dimension(unsigned int dim) {
-      return ( dim == 0 || dim == 1 ) ? N : BaseTraits::Dimension(dim - 2); }
     GridTypeMapper_RepeatedTypes;
+    using tensor_reduced  = iScalar<typename BaseTraits::tensor_reduced>;
+    using scalar_object   = iMatrix<typename BaseTraits::scalar_object,   N>;
+    using Complexified    = iMatrix<typename BaseTraits::Complexified,    N>;
+    using Realified       = iMatrix<typename BaseTraits::Realified,       N>;
+    using DoublePrecision = iMatrix<typename BaseTraits::DoublePrecision, N>;
+    static constexpr int Rank = BaseTraits::Rank + 2;
+    static constexpr std::size_t count = BaseTraits::count * N * N;
+    static constexpr int Dimension(int dim) {
+      return ( dim == 0 || dim == 1 ) ? N : BaseTraits::Dimension(dim - 2); }
   };
 
   // Match the index