From 7c69c1eeb26bdb986e86ed1886f55ae7b1e1b2fe Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Sun, 11 Aug 2024 12:28:41 +0200
Subject: [PATCH] deduplicate type traits

---
 common/include/algebra/type_traits.hpp        |  99 +++++++++-
 .../array/include/algebra/storage/array.hpp   | 119 +-----------
 .../eigen/include/algebra/storage/eigen.hpp   | 114 ++----------
 .../fastor/include/algebra/storage/fastor.hpp | 174 +-----------------
 .../include/algebra/storage/smatrix.hpp       | 100 +---------
 .../vc_aos/include/algebra/storage/vc_aos.hpp | 127 +------------
 .../vc_soa/include/algebra/storage/vc_soa.hpp | 108 +----------
 .../vecmem/include/algebra/storage/vecmem.hpp | 132 ++-----------
 8 files changed, 159 insertions(+), 814 deletions(-)

diff --git a/common/include/algebra/type_traits.hpp b/common/include/algebra/type_traits.hpp
index 53adf683..7cdda65d 100644
--- a/common/include/algebra/type_traits.hpp
+++ b/common/include/algebra/type_traits.hpp
@@ -121,6 +121,101 @@ template <class M>
 using block_getter_t = typename block_getter<M>::type;
 /// @}
 
-/// @}
-
 }  // namespace algebra::trait
+
+/// Default type trait specializations
+/// @{
+#define ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(A)                           \
+                                                                        \
+  namespace trait {                                                     \
+                                                                        \
+  template <typename T, auto N>                                         \
+  struct index<A::vector_type<T, N>> {                                  \
+    using type = algebra::A::size_type;                                 \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct index<A::matrix_type<T, ROWS, COLS>> {                         \
+    using type = algebra::A::size_type;                                 \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto N>                                         \
+  struct dimensions<A::vector_type<T, N>> {                             \
+                                                                        \
+    using size_type = index_t<A::vector_type<T, N>>;                    \
+                                                                        \
+    static constexpr size_type dim{1};                                  \
+    static constexpr size_type rows{N};                                 \
+    static constexpr size_type columns{1};                              \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct dimensions<A::matrix_type<T, ROWS, COLS>> {                    \
+                                                                        \
+    using size_type = index_t<A::matrix_type<T, ROWS, COLS>>;           \
+                                                                        \
+    static constexpr size_type dim{2};                                  \
+    static constexpr size_type rows{ROWS};                              \
+    static constexpr size_type columns{COLS};                           \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto N>                                         \
+  struct value<A::vector_type<T, N>> {                                  \
+    using type = T;                                                     \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct value<A::matrix_type<T, ROWS, COLS>> {                         \
+    using type = T;                                                     \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto N>                                         \
+  struct vector<A::vector_type<T, N>> {                                 \
+                                                                        \
+    template <typename other_T, auto other_N>                           \
+    using other_type = A::vector_type<other_T, other_N>;                \
+                                                                        \
+    using type = other_type<T, N>;                                      \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct vector<A::matrix_type<T, ROWS, COLS>> {                        \
+                                                                        \
+    template <typename other_T, auto other_N>                           \
+    using other_type = A::vector_type<other_T, other_N>;                \
+                                                                        \
+    using type = other_type<T, ROWS>;                                   \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct matrix<A::matrix_type<T, ROWS, COLS>> {                        \
+    template <typename other_T, auto other_ROWS, auto other_COLS>       \
+    using other_type = A::matrix_type<other_T, other_ROWS, other_COLS>; \
+                                                                        \
+    using type = A::matrix_type<T, ROWS, COLS>;                         \
+  };                                                                    \
+                                                                        \
+  template <typename T, int N>                                          \
+  struct matrix<A::vector_type<T, N>> {                                 \
+    template <typename other_T, int other_ROWS, int other_COLS>         \
+    using other_type = A::matrix_type<other_T, other_ROWS, other_COLS>; \
+                                                                        \
+    using type = other_type<T, N, 1>;                                   \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto N>                                         \
+  struct element_getter<A::vector_type<T, N>> {                         \
+    using type = A::element_getter;                                     \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct element_getter<A::matrix_type<T, ROWS, COLS>> {                \
+    using type = A::element_getter;                                     \
+  };                                                                    \
+                                                                        \
+  template <typename T, auto ROWS, auto COLS>                           \
+  struct block_getter<A::matrix_type<T, ROWS, COLS>> {                  \
+    using type = A::block_getter;                                       \
+  };                                                                    \
+                                                                        \
+  }  // namespace algebra::trait
diff --git a/storage/array/include/algebra/storage/array.hpp b/storage/array/include/algebra/storage/array.hpp
index 49226ecf..ed79c674 100644
--- a/storage/array/include/algebra/storage/array.hpp
+++ b/storage/array/include/algebra/storage/array.hpp
@@ -44,120 +44,13 @@ using vector2 = storage_type<T, 2>;
 template <typename T>
 using point2 = vector2<T>;
 
-}  // namespace array
-
-namespace trait {
-
-/// Type trait specializations
-/// @{
-
-/// Index
-/// @{
-template <typename T, std::size_t N>
-struct index<std::array<T, N>> {
-  using type = algebra::array::size_type;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct index<std::array<std::array<T, ROWS>, COLS>> {
-  using type = algebra::array::size_type;
-};
-/// @}
-
-/// Dimension
-/// @{
-template <typename T, std::size_t N>
-struct dimensions<std::array<T, N>> {
-
-  using size_type = index_t<std::array<T, N>>;
-
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct dimensions<std::array<std::array<T, ROWS>, COLS>> {
-
-  using size_type = index_t<std::array<std::array<T, ROWS>, COLS>>;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-/// @}
-
-/// Value
-/// @{
-template <typename T, std::size_t N>
-struct value<std::array<T, N>> {
-  using type = T;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct value<std::array<std::array<T, ROWS>, COLS>> {
-  using type = T;
-};
-/// @}
+/// Element Getter
+using element_getter = cmath::storage::element_getter;
+/// Block Getter
+using block_getter = cmath::storage::block_getter;
 
-/// Vector
-/// @{
-template <typename T, std::size_t N>
-struct vector<std::array<T, N>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type = std::array<other_T, other_N>;
-
-  using type = other_type<T, N>;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct vector<std::array<std::array<T, ROWS>, COLS>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type = std::array<other_T, other_N>;
-
-  using type = other_type<T, ROWS>;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct matrix<std::array<std::array<T, ROWS>, COLS>> {
-  template <typename other_T, std::size_t other_ROWS, std::size_t other_COLS>
-  using other_type = std::array<std::array<other_T, other_ROWS>, other_COLS>;
-
-  using type = std::array<std::array<T, ROWS>, COLS>;
-};
-
-template <typename T, int N>
-struct matrix<std::array<T, N>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = std::array<std::array<other_T, other_ROWS>, other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-/// @}
-
-/// Elemet/Block Getter
-/// @{
-template <typename T, std::size_t N>
-struct element_getter<std::array<T, N>> {
-  using type = cmath::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct element_getter<std::array<std::array<T, ROWS>, COLS>> {
-  using type = cmath::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct block_getter<std::array<std::array<T, ROWS>, COLS>> {
-  using type = cmath::storage::block_getter;
-};
-/// @}
+}  // namespace array
 
-}  // namespace trait
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(array)
 
 }  // namespace algebra
diff --git a/storage/eigen/include/algebra/storage/eigen.hpp b/storage/eigen/include/algebra/storage/eigen.hpp
index cb193743..cced2081 100644
--- a/storage/eigen/include/algebra/storage/eigen.hpp
+++ b/storage/eigen/include/algebra/storage/eigen.hpp
@@ -32,62 +32,46 @@ using vector_type = storage_type<T, N>;
 template <typename T, size_type ROWS, size_type COLS>
 using matrix_type = Eigen::Matrix<T, ROWS, COLS, (ROWS == 1), ROWS, COLS>;
 
-/// 3-element "vector" type, using @c algebra::eigen::array
+/// 3-element "vector" type, using @c eigen::vector_type
 template <typename T>
 using vector3 = storage_type<T, 3>;
-/// Point in 3D space, using @c algebra::eigen::array
+/// Point in 3D space, using @c eigen::vector_type
 template <typename T>
 using point3 = vector3<T>;
-/// 2-element "vector" type, using @c algebra::eigen::array
+/// 2-element "vector" type, using @c eigen::vector_type
 template <typename T>
 using vector2 = storage_type<T, 2>;
-/// Point in 2D space, using @c algebra::eigen::array
+/// Point in 2D space, using @c eigen::vector_type
 template <typename T>
 using point2 = vector2<T>;
 
+/// Element Getter
+using element_getter = eigen::storage::element_getter;
+/// Block Getter
+using block_getter = eigen::storage::block_getter;
+
 }  // namespace eigen
 
-namespace trait {
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(eigen)
 
-/// Type trait specializations
-/// @{
+// Extra specializations needed for some additional eigen types
+namespace trait {
 
 /// Index
 /// @{
-template <typename T, int N>
-struct index<algebra::eigen::array<T, N>> {
-  using type = algebra::eigen::size_type;
-};
-
 template <typename derived_t>
 struct index<Eigen::MatrixBase<derived_t>> {
   using type = algebra::eigen::size_type;
 };
 
-template <typename T, int ROWS, int COLS, int OPT>
-struct index<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-  using type = algebra::eigen::size_type;
-};
-
 template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
-struct index<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
-                          bCOLS, false>> {
+struct index<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS, bCOLS, false>> {
   using type = algebra::eigen::size_type;
 };
 /// @}
 
 /// Dimensions
 /// @{
-template <typename T, int N>
-struct dimensions<algebra::eigen::array<T, N>> {
-
-  using size_type = index_t<algebra::eigen::array<T, N>>;
-
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
-};
-
 template <typename derived_t>
 struct dimensions<Eigen::MatrixBase<derived_t>> {
 
@@ -100,16 +84,6 @@ struct dimensions<Eigen::MatrixBase<derived_t>> {
       Eigen::MatrixBase<derived_t>::ColsAtCompileTime};
 };
 
-template <typename T, int ROWS, int COLS, int OPT>
-struct dimensions<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-
-  using size_type = index_t<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>>;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-
 template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
 struct dimensions<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>,
                                bROWS, bCOLS, false>> {
@@ -126,21 +100,11 @@ struct dimensions<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>,
 
 /// Value
 /// @{
-template <typename T, int N>
-struct value<algebra::eigen::array<T, N>> {
-  using type = T;
-};
-
 template <typename derived_t>
 struct value<Eigen::MatrixBase<derived_t>> {
   using type = typename Eigen::MatrixBase<derived_t>::value_type;
 };
 
-template <typename T, int ROWS, int COLS, int OPT>
-struct value<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-  using type = T;
-};
-
 template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
 struct value<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
                           bCOLS, false>> {
@@ -150,33 +114,15 @@ struct value<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
 
 /// Vector
 /// @{
-template <typename T, int N>
-struct vector<algebra::eigen::array<T, N>> {
-
-  template <typename other_T, int other_N>
-  using other_type = algebra::eigen::array<other_T, other_N>;
-
-  using type = other_type<T, N>;
-};
-
 template <typename derived_t>
 struct vector<Eigen::MatrixBase<derived_t>> {
 
   template <typename other_T, int other_N>
-  using other_type = algebra::eigen::array<other_T, other_N>;
+  using other_type = eigen::vector_type<other_T, other_N>;
 
   using type = other_type<value_t<Eigen::MatrixBase<derived_t>>,
                           rows<Eigen::MatrixBase<derived_t>>>;
 };
-
-template <typename T, int ROWS, int COLS, int OPT>
-struct vector<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-
-  template <typename other_T, int other_N>
-  using other_type = algebra::eigen::array<other_T, other_N>;
-
-  using type = other_type<T, ROWS>;
-};
 /// @}
 
 /// Matrix
@@ -192,22 +138,6 @@ struct matrix<Eigen::MatrixBase<derived_t>> {
   using type = Eigen::MatrixBase<derived_t>;
 };
 
-template <typename T, int ROWS, int COLS, int OPT>
-struct matrix<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = eigen::matrix_type<other_T, other_ROWS, other_COLS>;
-
-  using type = Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>;
-};
-
-template <typename T, int N>
-struct matrix<algebra::eigen::array<T, N>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = eigen::matrix_type<other_T, other_ROWS, other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-
 template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
 struct matrix<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
                            bCOLS, false>> {
@@ -221,21 +151,11 @@ struct matrix<Eigen::Block<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS,
 
 /// Element getter
 /// @{
-template <typename T, int N>
-struct element_getter<algebra::eigen::array<T, N>> {
-  using type = eigen::storage::element_getter;
-};
-
 template <typename derived_t>
 struct element_getter<Eigen::MatrixBase<derived_t>> {
   using type = eigen::storage::element_getter;
 };
 
-template <typename T, int ROWS, int COLS, int OPT>
-struct element_getter<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-  using type = eigen::storage::element_getter;
-};
-
 template <typename T, int ROWS, int COLS, int OPT, int bROWS, int bCOLS>
 struct element_getter<Eigen::Block<
     Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>, bROWS, bCOLS, false>> {
@@ -249,12 +169,6 @@ template <typename derived_t>
 struct block_getter<Eigen::MatrixBase<derived_t>> {
   using type = eigen::storage::block_getter;
 };
-
-template <typename T, int ROWS, int COLS, int OPT>
-struct block_getter<Eigen::Matrix<T, ROWS, COLS, OPT, ROWS, COLS>> {
-  using type = eigen::storage::block_getter;
-};
-/// @}
 /// @}
 
 }  // namespace trait
diff --git a/storage/fastor/include/algebra/storage/fastor.hpp b/storage/fastor/include/algebra/storage/fastor.hpp
index c58271f9..8b2ccb98 100644
--- a/storage/fastor/include/algebra/storage/fastor.hpp
+++ b/storage/fastor/include/algebra/storage/fastor.hpp
@@ -24,6 +24,9 @@ using size_type = std::size_t;
 /// Array type used in the Fastor storage model
 template <typename T, size_type N>
 using storage_type = Fastor::Tensor<T, N>;
+/// Vector type used in the Fastor storage model
+template <typename T, size_type N>
+using vector_type = storage_type<T, N>;
 /// Matrix type used in the Fastor storage model
 template <typename T, size_type ROWS, size_type COLS>
 using matrix_type = algebra::fastor::Matrix<T, ROWS, COLS>;
@@ -41,172 +44,13 @@ using vector2 = storage_type<T, 2>;
 template <typename T>
 using point2 = vector2<T>;
 
-}  // namespace fastor
-
-namespace trait {
-
-/// Type trait specializations
-/// @{
-
-/// Index
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct index<Fastor::Tensor<T, ROWS, COLS>> {
-  using type = std::size_t;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct index<algebra::fastor::Matrix<T, ROWS, COLS>> {
-  using type = std::size_t;
-};
-
-template <typename T, std::size_t N>
-struct index<Fastor::Tensor<T, N>> {
-  using type = std::size_t;
-};
-/// @}
-
-/// Dimension
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct dimensions<Fastor::Tensor<T, ROWS, COLS>> {
-
-  using size_type = std::size_t;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct dimensions<algebra::fastor::Matrix<T, ROWS, COLS>> {
-
-  using size_type = std::size_t;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-
-template <typename T, std::size_t N>
-struct dimensions<Fastor::Tensor<T, N>> {
-
-  using size_type = std::size_t;
-
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
-};
-/// @}
-
-/// Value
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct value<Fastor::Tensor<T, ROWS, COLS>> {
-  using type = T;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct value<algebra::fastor::Matrix<T, ROWS, COLS>> {
-  using type = T;
-};
-
-template <typename T, std::size_t N>
-struct value<Fastor::Tensor<T, N>> {
-  using type = T;
-};
-/// @}
-
-/// Vector
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct vector<Fastor::Tensor<T, ROWS, COLS>> {
+/// Element Getter
+using element_getter = fastor::storage::element_getter;
+/// Block Getter
+using block_getter = fastor::storage::block_getter;
 
-  template <typename other_T, std::size_t other_N>
-  using other_type = Fastor::Tensor<other_T, other_N>;
-
-  using type = other_type<T, ROWS>;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct vector<algebra::fastor::Matrix<T, ROWS, COLS>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type = Fastor::Tensor<other_T, other_N>;
-
-  using type = Fastor::Tensor<T, ROWS>;
-};
-
-template <typename T, std::size_t N>
-struct vector<Fastor::Tensor<T, N>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type = Fastor::Tensor<other_T, other_N>;
-
-  using type = Fastor::Tensor<T, N>;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct matrix<Fastor::Tensor<T, ROWS, COLS>> {
-  template <typename other_T, std::size_t other_ROWS, std::size_t other_COLS>
-  using other_type = Fastor::Tensor<other_T, other_ROWS, other_COLS>;
-
-  using type = Fastor::Tensor<T, ROWS, COLS>;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct matrix<algebra::fastor::Matrix<T, ROWS, COLS>> {
-  template <typename other_T, std::size_t other_ROWS, std::size_t other_COLS>
-  using other_type = algebra::fastor::Matrix<other_T, other_ROWS, other_COLS>;
-
-  using type = algebra::fastor::Matrix<T, ROWS, COLS>;
-};
-
-template <typename T, int N>
-struct matrix<Fastor::Tensor<T, N>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = algebra::fastor::Matrix<other_T, other_ROWS, other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-/// @}
-
-/// Element/Block Getter
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct element_getter<Fastor::Tensor<T, ROWS, COLS>> {
-  using type = fastor::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct element_getter<algebra::fastor::Matrix<T, ROWS, COLS>> {
-  using type = fastor::storage::element_getter;
-};
-
-template <typename T, std::size_t N>
-struct element_getter<Fastor::Tensor<T, N>> {
-  using type = fastor::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct block_getter<Fastor::Tensor<T, ROWS, COLS>> {
-  using type = fastor::storage::block_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct block_getter<algebra::fastor::Matrix<T, ROWS, COLS>> {
-  using type = fastor::storage::block_getter;
-};
-
-template <typename T, std::size_t N>
-struct block_getter<Fastor::Tensor<T, N>> {
-  using type = fastor::storage::block_getter;
-};
-/// @}
+}  // namespace fastor
 
-}  // namespace trait
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(fastor)
 
 }  // namespace algebra
diff --git a/storage/smatrix/include/algebra/storage/smatrix.hpp b/storage/smatrix/include/algebra/storage/smatrix.hpp
index 8527c10f..a78e56f0 100644
--- a/storage/smatrix/include/algebra/storage/smatrix.hpp
+++ b/storage/smatrix/include/algebra/storage/smatrix.hpp
@@ -44,101 +44,13 @@ using vector2 = storage_type<T, 2>;
 template <typename T>
 using point2 = vector2<T>;
 
-}  // namespace smatrix
-
-namespace trait {
-
-/// Type trait specializations
-/// @{
-
-/// Index
-/// @{
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct index<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-  using type = unsigned int;
-};
-/// @}
-
-/// Dimension
-/// @{
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct dimensions<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-
-  using size_type = unsigned int;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-/// @}
-
-/// Value
-/// @{
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct value<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-  using type = T;
-};
-/// @}
-
-/// Vector
-/// @{
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct vector<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-
-  template <typename other_T, unsigned int other_N>
-  using other_type = ROOT::Math::SVector<other_T, other_N>;
-
-  using type = other_type<T, ROWS>;
-};
+/// Element Getter
+using element_getter = smatrix::storage::element_getter;
+/// Block Getter
+using block_getter = smatrix::storage::block_getter;
 
-template <typename T, unsigned int N>
-struct vector<ROOT::Math::SVector<T, N>> {
-  using type = ROOT::Math::SVector<T, N>;
-
-  template <typename other_T, unsigned int other_N>
-  using other_type = ROOT::Math::SVector<other_T, other_N>;
-
-  using type = other_type<T, N>;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct matrix<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-  template <typename other_T, unsigned int other_ROWS, unsigned int other_COLS>
-  using other_type = ROOT::Math::SMatrix<other_T, other_ROWS, other_COLS, expr>;
-
-  using type = ROOT::Math::SMatrix<T, ROWS, COLS, expr>;
-};
-
-template <typename T, int N>
-struct matrix<ROOT::Math::SVector<T, N>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = ROOT::Math::SMatrix<other_T, other_ROWS, other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-/// @}
-
-/// Elemet/Block Getter
-/// @{
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct element_getter<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-  using type = smatrix::storage::element_getter;
-};
-
-template <typename T, unsigned int N>
-struct element_getter<ROOT::Math::SVector<T, N>> {
-  using type = smatrix::storage::element_getter;
-};
-
-template <typename T, unsigned int ROWS, unsigned int COLS, typename expr>
-struct block_getter<ROOT::Math::SMatrix<T, ROWS, COLS, expr>> {
-  using type = smatrix::storage::block_getter;
-};
-/// @}
+}  // namespace smatrix
 
-}  // namespace trait
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(smatrix)
 
 }  // namespace algebra
diff --git a/storage/vc_aos/include/algebra/storage/vc_aos.hpp b/storage/vc_aos/include/algebra/storage/vc_aos.hpp
index 4a5d334f..f3960d00 100644
--- a/storage/vc_aos/include/algebra/storage/vc_aos.hpp
+++ b/storage/vc_aos/include/algebra/storage/vc_aos.hpp
@@ -64,128 +64,13 @@ using vector6 = vector_type<T, 6>;
 template <typename T>
 using vector8 = vector_type<T, 8>;
 
-}  // namespace vc_aos
-
-namespace trait {
-
-/// Type trait specializations
-/// @{
-
-/// Index
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct index<algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-  using type = algebra::vc_aos::size_type;
-};
-
-template <typename T, std::size_t N>
-struct index<algebra::storage::vector<N, T, vc_aos::storage_type>> {
-  using type = algebra::vc_aos::size_type;
-};
-/// @}
-
-/// Dimension
-/// @{
-template <typename T, std::size_t N>
-struct dimensions<algebra::storage::vector<N, T, vc_aos::storage_type>> {
-
-  using size_type =
-      index_t<algebra::storage::vector<N, T, vc_aos::storage_type>>;
-
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct dimensions<
-    algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-
-  using size_type =
-      index_t<algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>>;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-/// @}
-
-/// Value
-/// @{
-template <typename T, std::size_t N>
-struct value<algebra::storage::vector<N, T, vc_aos::storage_type>> {
-  using type = T;
-};
+/// Element Getter
+using element_getter = algebra::storage::element_getter;
+/// Block Getter
+using block_getter = algebra::storage::block_getter;
 
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct value<algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-  using type = T;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, std::size_t N>
-struct vector<algebra::storage::vector<N, T, vc_aos::storage_type>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type =
-      algebra::storage::vector<other_N, other_T, vc_aos::storage_type>;
-
-  using type = other_type<T, N>;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct vector<algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type =
-      algebra::storage::vector<other_N, other_T, vc_aos::storage_type>;
-
-  using type = other_type<T, ROWS>;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct matrix<algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-  template <typename other_T, std::size_t other_ROWS, std::size_t other_COLS>
-  using other_type = algebra::storage::matrix<vc_aos::storage_type, other_T,
-                                              other_ROWS, other_COLS>;
-
-  using type = algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>;
-};
-
-template <typename T, int N>
-struct matrix<algebra::storage::vector<N, T, vc_aos::storage_type>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = algebra::storage::matrix<vc_aos::storage_type, other_T,
-                                              other_ROWS, other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-/// @}
-
-/// Elemet/Block Getter
-/// @{
-template <typename T, std::size_t N>
-struct element_getter<algebra::storage::vector<N, T, vc_aos::storage_type>> {
-  using type = algebra::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct element_getter<
-    algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-  using type = algebra::storage::element_getter;
-};
+}  // namespace vc_aos
 
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct block_getter<
-    algebra::storage::matrix<vc_aos::storage_type, T, ROWS, COLS>> {
-  using type = algebra::storage::block_getter;
-};
-/// @}
-}  // namespace trait
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(vc_aos)
 
 }  // namespace algebra
diff --git a/storage/vc_soa/include/algebra/storage/vc_soa.hpp b/storage/vc_soa/include/algebra/storage/vc_soa.hpp
index 905062be..c1821d45 100644
--- a/storage/vc_soa/include/algebra/storage/vc_soa.hpp
+++ b/storage/vc_soa/include/algebra/storage/vc_soa.hpp
@@ -40,11 +40,11 @@ template <typename T>
 using value_type = Vc::Vector<T>;
 /// Vector type used in the Vc SoA storage model
 template <typename T, std::size_t N>
-using vector_type = algebra::storage::vector<N, value_type<T>, storage_type>;
+using vector_type = algebra::storage::vector<N, Vc::Vector<T>, std::array>;
 /// Matrix type used in the Vc SoA storage model
 template <typename T, size_type ROWS, size_type COLS>
 using matrix_type =
-    algebra::storage::matrix<storage_type, value_type<T>, ROWS, COLS>;
+    algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>;
 
 /// 2-element "vector" type, using @c Vc::Vector in every element
 template <typename T>
@@ -65,113 +65,25 @@ using vector6 = vector_type<T, 6>;
 template <typename T>
 using vector8 = vector_type<T, 8>;
 
-}  // namespace vc_soa
-
-namespace trait {
+/// Element Getter
+using element_getter = algebra::storage::element_getter;
+/// Block Getter
+using block_getter = algebra::storage::block_getter;
 
-/// Type trait specializations
-/// @{
-
-/// Index
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct index<algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
-  using type = algebra::vc_soa::size_type;
-};
-/// @}
-
-/// Dimension
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct dimensions<
-    algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
+}  // namespace vc_soa
 
-  using size_type =
-      index_t<algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>>;
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(vc_soa)
 
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-/// @}
+namespace trait {
 
-/// Value/Scalar
+/// Make sure the simd scalar type is recognized correctly
 /// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct value<algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
-  using type = T;
-};
-
 template <typename T, std::size_t ROWS, std::size_t COLS>
 struct scalar<algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
   using type = Vc::Vector<T>;
 };
 /// @}
 
-/// Vector
-/// @{
-template <typename T, std::size_t N>
-struct vector<algebra::storage::vector<N, Vc::Vector<T>, std::array>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type =
-      algebra::storage::vector<other_N, Vc::Vector<other_T>, std::array>;
-
-  using type = other_type<T, N>;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct vector<algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type =
-      algebra::storage::vector<other_N, Vc::Vector<other_T>, std::array>;
-
-  using type = other_type<T, ROWS>;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct matrix<algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
-  template <typename other_T, std::size_t other_ROWS, std::size_t other_COLS>
-  using other_type = algebra::storage::matrix<std::array, Vc::Vector<other_T>,
-                                              other_ROWS, other_COLS>;
-
-  using type = algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>;
-};
-
-template <typename T, int N>
-struct matrix<algebra::storage::vector<N, Vc::Vector<T>, std::array>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type = algebra::storage::matrix<std::array, Vc::Vector<other_T>,
-                                              other_ROWS, other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-/// @}
-
-/// Elemet/Block Getter
-/// @{
-template <typename T, std::size_t N>
-struct element_getter<algebra::storage::vector<N, Vc::Vector<T>, std::array>> {
-  using type = algebra::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct element_getter<
-    algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
-  using type = algebra::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct block_getter<
-    algebra::storage::matrix<std::array, Vc::Vector<T>, ROWS, COLS>> {
-  using type = algebra::storage::block_getter;
-};
-/// @}
-
 }  // namespace trait
 
 }  // namespace algebra
diff --git a/storage/vecmem/include/algebra/storage/vecmem.hpp b/storage/vecmem/include/algebra/storage/vecmem.hpp
index 77ef938e..ec76106a 100644
--- a/storage/vecmem/include/algebra/storage/vecmem.hpp
+++ b/storage/vecmem/include/algebra/storage/vecmem.hpp
@@ -21,9 +21,14 @@ namespace algebra {
 
 namespace vecmem {
 
+/// size type for VecMem storage model
+using size_type = std::size_t;
 /// Array type used in the VecMem storage model
 template <typename T, std::size_t N>
 using storage_type = ::vecmem::static_array<T, N>;
+/// Vector type used in the VecMem storage model
+template <typename T, std::size_t N>
+using vector_type = storage_type<T, N>;
 /// Matrix type used in the VecMem storage model
 template <typename T, std::size_t ROWS, std::size_t COLS>
 using matrix_type = storage_type<storage_type<T, ROWS>, COLS>;
@@ -41,128 +46,13 @@ using vector2 = storage_type<T, 2>;
 template <typename T>
 using point2 = vector2<T>;
 
-}  // namespace vecmem
-
-namespace trait {
-
-/// Type trait specializations
-/// @{
-
-/// Index
-/// @{
-template <typename T, std::size_t N>
-struct index<::vecmem::static_array<T, N>> {
-  using type = std::size_t;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct index<::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-  using type = std::size_t;
-};
-/// @}
-
-/// Dimension
-/// @{
-template <typename T, std::size_t N>
-struct dimensions<::vecmem::static_array<T, N>> {
-
-  using size_type = index_t<::vecmem::static_array<T, N>>;
-
-  static constexpr size_type dim{1};
-  static constexpr size_type rows{N};
-  static constexpr size_type columns{1};
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct dimensions<
-    ::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-
-  using size_type =
-      index_t<::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>>;
-
-  static constexpr size_type dim{2};
-  static constexpr size_type rows{ROWS};
-  static constexpr size_type columns{COLS};
-};
-/// @}
-
-/// Value
-/// @{
-template <typename T, std::size_t N>
-struct value<::vecmem::static_array<T, N>> {
-  using type = T;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct value<::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-  using type = T;
-};
-/// @}
+/// Element Getter
+using element_getter = cmath::storage::element_getter;
+/// Block Getter
+using block_getter = cmath::storage::block_getter;
 
-/// Vector
-/// @{
-template <typename T, std::size_t N>
-struct vector<::vecmem::static_array<T, N>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type = ::vecmem::static_array<other_T, other_N>;
-
-  using type = other_type<T, N>;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct vector<::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-
-  template <typename other_T, std::size_t other_N>
-  using other_type = ::vecmem::static_array<other_T, other_N>;
-
-  using type = other_type<T, ROWS>;
-};
-/// @}
-
-/// Matrix
-/// @{
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct matrix<::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-  template <typename other_T, std::size_t other_ROWS, std::size_t other_COLS>
-  using other_type =
-      ::vecmem::static_array<::vecmem::static_array<other_T, other_ROWS>,
-                             other_COLS>;
-
-  using type = ::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>;
-};
-
-template <typename T, int N>
-struct matrix<::vecmem::static_array<T, N>> {
-  template <typename other_T, int other_ROWS, int other_COLS>
-  using other_type =
-      ::vecmem::static_array<::vecmem::static_array<other_T, other_ROWS>,
-                             other_COLS>;
-
-  using type = other_type<T, N, 1>;
-};
-/// @}
-
-/// Elemet/Block Getter
-/// @{
-template <typename T, std::size_t N>
-struct element_getter<::vecmem::static_array<T, N>> {
-  using type = cmath::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct element_getter<
-    ::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-  using type = cmath::storage::element_getter;
-};
-
-template <typename T, std::size_t ROWS, std::size_t COLS>
-struct block_getter<
-    ::vecmem::static_array<::vecmem::static_array<T, ROWS>, COLS>> {
-  using type = cmath::storage::block_getter;
-};
-/// @}
+}  // namespace vecmem
 
-}  // namespace trait
+ALGEBRA_PLUGINS_DEFINE_TYPE_TRAITS(vecmem)
 
 }  // namespace algebra