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/impl/smatrix_getter.hpp b/storage/smatrix/include/algebra/storage/impl/smatrix_getter.hpp
index 5184e0ba..5c725c1a 100644
--- a/storage/smatrix/include/algebra/storage/impl/smatrix_getter.hpp
+++ b/storage/smatrix/include/algebra/storage/impl/smatrix_getter.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s).
 #include "algebra/qualifiers.hpp"
+#include "algebra/storage/smatrix.hpp"
 
 // ROOT/Smatrix include(s).
 #include <Math/Expression.h>
@@ -26,16 +27,16 @@ namespace algebra::smatrix::storage {
 template <typename scalar_t>
 struct element_getter {
 
-  template <unsigned int ROWS, unsigned int COLS, typename scalar_t>
-  ALGEBRA_HOST_DEVICE inline scalar_t &operator()(ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m,
-                                                  unsigned int row,
-                                                  unsigned int col) const {
+  template <unsigned int ROWS, unsigned int COLS>
+  ALGEBRA_HOST_DEVICE inline scalar_t &operator()(
+      ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, unsigned int row,
+      unsigned int col) const {
     assert(row < ROWS);
     assert(col < COLS);
     return m(row, col);
   }
 
-  template <unsigned int ROWS, unsigned int COLS, typename scalar_t>
+  template <unsigned int ROWS, unsigned int COLS>
   ALGEBRA_HOST_DEVICE inline scalar_t operator()(
       const ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, unsigned int row,
       unsigned int col) const {
@@ -44,31 +45,31 @@ struct element_getter {
     return m(row, col);
   }
 
-  template <unsigned int N, typename scalar_t>
-  ALGEBRA_HOST_DEVICE inline scalar_t &operator()(ROOT::Math::SMatrix<scalar_t, N, 1> &m,
-                                                  unsigned int row) const {
-    assert(row < ROWS);
+  template <unsigned int N>
+  ALGEBRA_HOST_DEVICE inline scalar_t &operator()(
+      ROOT::Math::SMatrix<scalar_t, N, 1> &m, unsigned int row) const {
+    assert(row < N);
     return m(row);
   }
 
-  template <unsigned int N, typename scalar_t>
+  template <unsigned int N>
   ALGEBRA_HOST_DEVICE inline scalar_t operator()(
       const ROOT::Math::SMatrix<scalar_t, N, 1> &m, unsigned int row) const {
-    assert(row < ROWS);
+    assert(row < N);
     return m(row);
   }
 
-  template <unsigned int N, typename scalar_t>
-  ALGEBRA_HOST_DEVICE inline scalar_t &operator()(ROOT::Math::SVector<scalar_t, N> &m,
-                                                  unsigned int row) const {
-    assert(row < ROWS);
+  template <unsigned int N>
+  ALGEBRA_HOST_DEVICE inline scalar_t &operator()(
+      ROOT::Math::SVector<scalar_t, N> &m, unsigned int row) const {
+    assert(row < N);
     return m(row);
   }
 
-  template <unsigned int N, typename scalar_t>
+  template <unsigned int N>
   ALGEBRA_HOST_DEVICE inline scalar_t operator()(
       const ROOT::Math::SVector<scalar_t, N> &m, unsigned int row) const {
-    assert(row < ROWS);
+    assert(row < N);
     return m(row);
   }
 };  // element_getter
@@ -78,7 +79,8 @@ template <typename scalar_t, unsigned int ROWS, unsigned int COLS>
 ALGEBRA_HOST_DEVICE inline scalar_t element(
     const ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, std::size_t row,
     std::size_t col) {
-  return element_getter<scalar_t>()(m, static_cast<unsigned int>(row), static_cast<unsigned int>(col));
+  return element_getter<scalar_t>()(m, static_cast<unsigned int>(row),
+                                    static_cast<unsigned int>(col));
 }
 
 /// Function extracting an element from a matrix (non-const)
@@ -86,7 +88,8 @@ template <typename scalar_t, unsigned int ROWS, unsigned int COLS>
 ALGEBRA_HOST_DEVICE inline scalar_t &element(
     ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, std::size_t row,
     std::size_t col) {
-  return element_getter<scalar_t>()(m, static_cast<unsigned int>(row), static_cast<unsigned int>(col));
+  return element_getter<scalar_t>()(m, static_cast<unsigned int>(row),
+                                    static_cast<unsigned int>(col));
 }
 
 /// Function extracting an element from a matrix (const)
@@ -113,35 +116,40 @@ ALGEBRA_HOST_DEVICE inline scalar_t element(
 /// Function extracting an element from a matrix (non-const)
 template <typename scalar_t, unsigned int N>
 ALGEBRA_HOST_DEVICE inline scalar_t &element(
-    ROOT::Math::SVector<scalar_t, N, 1> &m, std::size_t row) {
+    ROOT::Math::SVector<scalar_t, N> &m, std::size_t row) {
   return element_getter<scalar_t>()(m, static_cast<unsigned int>(row));
 }
 
 /// Functor used to extract a block from SMatrix matrices
 struct block_getter {
 
-  template <unsigned int ROWS, unsigned int COLS, unsigned int oROWS, unsigned int oCOLS, typename scalar_t>
+  template <unsigned int ROWS, unsigned int COLS, unsigned int oROWS,
+            unsigned int oCOLS, typename scalar_t>
   ALGEBRA_HOST_DEVICE ROOT::Math::SMatrix<scalar_t, ROWS, COLS> operator()(
-      const ROOT::Math::SMatrix<scalar_t, oROWS, oCOLS> &m, unsigned int row, unsigned int col) const {
+      const ROOT::Math::SMatrix<scalar_t, oROWS, oCOLS> &m, unsigned int row,
+      unsigned int col) const {
 
     return m.template Sub<ROOT::Math::SMatrix<scalar_t, ROWS, COLS>>(row, col);
   }
 
-  template <unsigned int SIZE, unsigned int ROWS, unsigned int COLS, typename scalar_t>
+  template <unsigned int SIZE, unsigned int ROWS, unsigned int COLS,
+            typename scalar_t>
   ALGEBRA_HOST_DEVICE ROOT::Math::SVector<scalar_t, SIZE> operator()(
-      const ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, unsigned int row, unsigned int col) const {
+      const ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, unsigned int row,
+      unsigned int col) const {
 
-  return m.template SubCol<ROOT::Math::SVector<scalar_t, SIZE>>(col, row);
+    return m.template SubCol<ROOT::Math::SVector<scalar_t, SIZE>>(col, row);
   }
 };  // struct block_getter
 
 /// Operator getting a block of a const matrix
-template <unsigned int ROWS, unsigned int COLS, unsigned int oROWS, unsigned int oCOLS,
-          typename scalar_t>
-ALGEBRA_HOST_DEVICE matrix_type<ROWS, COLS> block(const ROOT::Math::SMatrix<scalar_t, oROWS, oCOLS>&m,
-                                                  std::size_t row,
-                                                  std::size_t col) {
-  return block_getter{}.template operator()<ROWS, COLS>(m, static_cast<unsigned int>(row), static_cast<unsigned int>(col));
+template <unsigned int ROWS, unsigned int COLS, unsigned int oROWS,
+          unsigned int oCOLS, typename scalar_t>
+ALGEBRA_HOST_DEVICE matrix_type<ROWS, COLS> block(
+    const ROOT::Math::SMatrix<scalar_t, oROWS, oCOLS> &m, std::size_t row,
+    std::size_t col) {
+  return block_getter{}.template operator()<ROWS, COLS>(
+      m, static_cast<unsigned int>(row), static_cast<unsigned int>(col));
 }
 
 /// Function extracting a slice from the matrix used by
@@ -149,10 +157,11 @@ ALGEBRA_HOST_DEVICE matrix_type<ROWS, COLS> block(const ROOT::Math::SMatrix<scal
 template <unsigned int SIZE, unsigned int ROWS, unsigned int COLS,
           typename scalar_t>
 ALGEBRA_HOST_DEVICE inline auto vector(
-    const ROOT::Math::SMatrix<scalar_t, ROWS, COLS>& m, std::size_t row,
+    const ROOT::Math::SMatrix<scalar_t, ROWS, COLS> &m, std::size_t row,
     std::size_t col) {
 
-  return block_getter{}.template operator()<SIZE>(m, static_cast<unsigned int>(row), static_cast<unsigned int>(col));
+  return block_getter{}.template operator()<SIZE>(
+      m, static_cast<unsigned int>(row), static_cast<unsigned int>(col));
 }
 
 /// Operator setting a block with a matrix
@@ -162,7 +171,8 @@ ALGEBRA_HOST_DEVICE void set_block(input_matrix_type &m,
                                    std::size_t row, std::size_t col) {
   for (unsigned int i = 0; i < ROWS; ++i) {
     for (unsigned int j = 0; j < COLS; ++j) {
-      m(i + static_cast<unsigned int>(row), j + static_cast<unsigned int>(col)) = b(i, j);
+      m(i + static_cast<unsigned int>(row),
+        j + static_cast<unsigned int>(col)) = b(i, j);
     }
   }
 }
@@ -177,4 +187,4 @@ ALGEBRA_HOST_DEVICE void set_block(input_matrix_type &m,
   }
 }
 
-}  // namespace algebra::smatrix
+}  // namespace algebra::smatrix::storage
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