diff --git a/src/dev/ParallelChecker.hpp b/src/dev/ParallelChecker.hpp
index 97d82ee4bac3badfdc760c973d81454e89102200..22273e38c1a78dc5359e8b13f1f22c227a4c6eae 100644
--- a/src/dev/ParallelChecker.hpp
+++ b/src/dev/ParallelChecker.hpp
@@ -1,10 +1,7 @@
 #ifndef PARALLEL_CHECKER_HPP
 #define PARALLEL_CHECKER_HPP
 
-#include <utils/pugs_config.hpp>
-#ifdef PUGS_HAS_HDF5
-#include <highfive/highfive.hpp>
-#endif   // PUGS_HAS_HDF5
+#include <utils/HighFivePugsUtils.hpp>
 
 #include <mesh/Connectivity.hpp>
 #include <mesh/ItemArrayVariant.hpp>
@@ -86,34 +83,6 @@ class ParallelChecker
 
 #ifdef PUGS_HAS_HDF5
  private:
-  template <typename T>
-  struct TinyVectorDataType;
-
-  template <size_t Dimension, typename DataT>
-  struct TinyVectorDataType<TinyVector<Dimension, DataT>> : public HighFive::DataType
-  {
-    TinyVectorDataType()
-    {
-      hsize_t dim[]     = {Dimension};
-      auto h5_data_type = HighFive::create_datatype<DataT>();
-      _hid              = H5Tarray_create(h5_data_type.getId(), 1, dim);
-    }
-  };
-
-  template <typename T>
-  struct TinyMatrixDataType;
-
-  template <size_t M, size_t N, typename DataT>
-  struct TinyMatrixDataType<TinyMatrix<M, N, DataT>> : public HighFive::DataType
-  {
-    TinyMatrixDataType()
-    {
-      hsize_t dim[]     = {M, N};
-      auto h5_data_type = HighFive::create_datatype<DataT>();
-      _hid              = H5Tarray_create(h5_data_type.getId(), 2, dim);
-    }
-  };
-
   HighFive::File
   _createOrOpenFileRW() const
   {
@@ -140,20 +109,8 @@ class ParallelChecker
   _writeArray(HighFive::Group& group, const std::string& name, const Array<DataType>& array) const
   {
     using data_type = std::remove_const_t<DataType>;
-    if constexpr (is_tiny_vector_v<data_type>) {
-      auto dataset = group.createDataSet(name, HighFive::DataSpace{std::vector<size_t>{array.size()}},
-                                         TinyVectorDataType<data_type>{});
-
-      dataset.template write_raw<typename data_type::data_type>(&(array[0][0]), TinyVectorDataType<data_type>{});
-    } else if constexpr (is_tiny_matrix_v<data_type>) {
-      auto dataset = group.createDataSet(name, HighFive::DataSpace{std::vector<size_t>{array.size()}},
-                                         TinyMatrixDataType<data_type>{});
-
-      dataset.template write_raw<typename data_type::data_type>(&(array[0](0, 0)), TinyMatrixDataType<data_type>{});
-    } else {
-      auto dataset = group.createDataSet<data_type>(name, HighFive::DataSpace{std::vector<size_t>{array.size()}});
-      dataset.template write_raw<data_type>(&(array[0]));
-    }
+    auto dataset    = group.createDataSet<data_type>(name, HighFive::DataSpace{std::vector<size_t>{array.size()}});
+    dataset.template write_raw<data_type>(&(array[0]));
   }
 
   template <typename DataType>
@@ -161,26 +118,10 @@ class ParallelChecker
   _writeTable(HighFive::Group& group, const std::string& name, const Table<DataType>& table) const
   {
     using data_type = std::remove_const_t<DataType>;
-    if constexpr (is_tiny_vector_v<data_type>) {
-      auto dataset =
-        group.createDataSet(name,
-                            HighFive::DataSpace{std::vector<size_t>{table.numberOfRows(), table.numberOfColumns()}},
-                            TinyVectorDataType<data_type>{});
-
-      dataset.template write_raw<typename data_type::data_type>(&(table(0, 0)[0]), TinyVectorDataType<data_type>{});
-    } else if constexpr (is_tiny_matrix_v<data_type>) {
-      auto dataset =
-        group.createDataSet(name,
-                            HighFive::DataSpace{std::vector<size_t>{table.numberOfRows(), table.numberOfColumns()}},
-                            TinyMatrixDataType<data_type>{});
-
-      dataset.template write_raw<typename data_type::data_type>(&(table(0, 0)(0, 0)), TinyMatrixDataType<data_type>{});
-    } else {
-      auto dataset =
-        group.createDataSet<data_type>(name, HighFive::DataSpace{
-                                               std::vector<size_t>{table.numberOfRows(), table.numberOfColumns()}});
-      dataset.template write_raw<data_type>(&(table(0, 0)));
-    }
+    auto dataset =
+      group.createDataSet<data_type>(name, HighFive::DataSpace{
+                                             std::vector<size_t>{table.numberOfRows(), table.numberOfColumns()}});
+    dataset.template write_raw<data_type>(&(table(0, 0)));
   }
 
   template <typename DataType>
@@ -192,13 +133,7 @@ class ParallelChecker
     auto dataset = group.getDataSet(name);
     Array<data_type> array(dataset.getElementCount());
 
-    if constexpr (is_tiny_vector_v<data_type>) {
-      dataset.read<data_type>(&(array[0]), TinyVectorDataType<data_type>{});
-    } else if constexpr (is_tiny_matrix_v<data_type>) {
-      dataset.read<data_type>(&(array[0]), TinyMatrixDataType<data_type>{});
-    } else {
-      dataset.read<data_type>(&(array[0]));
-    }
+    dataset.read<data_type>(&(array[0]));
     return array;
   }
 
@@ -211,13 +146,7 @@ class ParallelChecker
     auto dataset = group.getDataSet(name);
     Table<data_type> table(dataset.getDimensions()[0], dataset.getDimensions()[1]);
 
-    if constexpr (is_tiny_vector_v<data_type>) {
-      dataset.read<data_type>(&(table(0, 0)), TinyVectorDataType<data_type>{});
-    } else if constexpr (is_tiny_matrix_v<data_type>) {
-      dataset.read<data_type>(&(table(0, 0)), TinyMatrixDataType<data_type>{});
-    } else {
-      dataset.read<data_type>(&(table(0, 0)));
-    }
+    dataset.read<data_type>(&(table(0, 0)));
     return table;
   }
 
diff --git a/src/utils/HighFivePugsUtils.hpp b/src/utils/HighFivePugsUtils.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8657e8aff68bb93a388962004fb5456101b13aef
--- /dev/null
+++ b/src/utils/HighFivePugsUtils.hpp
@@ -0,0 +1,44 @@
+#ifndef HIGH_FIVE_PUGS_UTILS_HPP
+#define HIGH_FIVE_PUGS_UTILS_HPP
+
+#include <utils/pugs_config.hpp>
+
+#ifdef PUGS_HAS_HDF5
+#include <highfive/highfive.hpp>
+
+template <size_t Dimension, typename T>
+class TinyVector;
+template <size_t M, size_t N, typename T>
+class TinyMatrix;
+
+namespace HighFive
+{
+template <size_t Dimension, typename T>
+class AtomicType<TinyVector<Dimension, T>> : public HighFive::DataType
+{
+ public:
+  inline AtomicType()
+  {
+    hsize_t dim[]     = {Dimension};
+    auto h5_data_type = HighFive::create_datatype<T>();
+    _hid              = H5Tarray_create(h5_data_type.getId(), 1, dim);
+  }
+};
+
+template <size_t M, size_t N, typename T>
+class AtomicType<TinyMatrix<M, N, T>> : public HighFive::DataType
+{
+ public:
+  inline AtomicType()
+  {
+    hsize_t dim[]     = {M, N};
+    auto h5_data_type = HighFive::create_datatype<T>();
+    _hid              = H5Tarray_create(h5_data_type.getId(), 2, dim);
+  }
+};
+
+}   // namespace HighFive
+
+#endif   // PUGS_HAS_HDF5
+
+#endif   // HIGH_FIVE_PUGS_UTILS_HPP