From ef5b4f0846f0f59f1812157c5c07b8c6aa490354 Mon Sep 17 00:00:00 2001
From: Daniel Garcia-Sanchez <daniel.garcia-sanchez@insp.upmc.fr>
Date: Wed, 22 Aug 2018 11:22:38 +0200
Subject: [PATCH] Write parallel tests for the HDF5 datasets

---
 tests/base/hdf5_03.cc                         | 872 ++++++++++++++++++
 .../hdf5_03.with_hdf5=true.mpirun=1.output    | 337 +++++++
 .../hdf5_03.with_hdf5=true.mpirun=4.output    | 337 +++++++
 3 files changed, 1546 insertions(+)
 create mode 100644 tests/base/hdf5_03.cc
 create mode 100644 tests/base/hdf5_03.with_hdf5=true.mpirun=1.output
 create mode 100644 tests/base/hdf5_03.with_hdf5=true.mpirun=4.output

diff --git a/tests/base/hdf5_03.cc b/tests/base/hdf5_03.cc
new file mode 100644
index 0000000000..af88a364b7
--- /dev/null
+++ b/tests/base/hdf5_03.cc
@@ -0,0 +1,872 @@
+// ---------------------------------------------------------------------
+//
+// Copyright (C) 2015 - 2018 by the deal.II Authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+// Test read/write with parallel HDF5
+
+#include <deal.II/base/conditional_ostream.h>
+#include <deal.II/base/hdf5.h>
+
+#include <boost/type_traits.hpp>
+
+#include <numeric>
+
+#include "../tests.h"
+
+// This function initializes a container of Number type
+template <template <class...> class Container, typename Number>
+typename std::enable_if<
+  std::is_same<Container<Number>, std::vector<Number>>::value,
+  Container<Number>>::type
+initialize_container(std::vector<hsize_t> dimensions)
+{
+  return std::vector<Number>(std::accumulate(
+    dimensions.begin(), dimensions.end(), 1, std::multiplies<int>()));
+}
+
+template <template <class...> class Container, typename Number>
+typename std::enable_if<
+  std::is_same<Container<Number>, FullMatrix<Number>>::value,
+  Container<Number>>::type
+initialize_container(std::vector<hsize_t> dimensions)
+{
+  return FullMatrix<Number>(dimensions[0], dimensions[1]);
+}
+
+// This function calculates the sum of the elements in a container
+template <template <class...> class Container, typename Number>
+typename std::enable_if<
+  std::is_same<Container<Number>, std::vector<Number>>::value,
+  Number>::type
+container_sum(Container<Number> data)
+{
+  return std::accumulate(data.begin(), data.end(), static_cast<Number>(0));
+}
+
+template <template <class...> class Container, typename Number>
+typename std::enable_if<
+  std::is_same<Container<Number>, FullMatrix<Number>>::value,
+  Number>::type
+container_sum(Container<Number> data)
+{
+  Number sum = 0;
+  for (unsigned int row_idx = 0; row_idx < data.m(); ++row_idx)
+    {
+      for (unsigned int col_idx = 0; col_idx < data.n(); ++col_idx)
+        {
+          sum += data[row_idx][col_idx];
+        }
+    }
+  return sum;
+}
+
+
+// This function is used to get a complex component in complex datasets
+// If Number is scalar the function returns 1
+// If Number is complex the function returns 1 + 1j
+template <typename Number>
+typename std::enable_if<!boost::is_complex<Number>::value, Number>::type
+get_factor()
+{
+  return 1;
+}
+
+template <typename Number>
+typename std::enable_if<boost::is_complex<Number>::value, Number>::type
+get_factor()
+{
+  return static_cast<Number>(std::complex<float>(1, 1));
+}
+
+// This function assignes data to the elements of the container
+template <template <class...> class Container, typename Number>
+typename std::enable_if<
+  std::is_same<Container<Number>, std::vector<Number>>::value,
+  void>::type
+assign_data(Container<Number> &data)
+{
+  for (unsigned int idx = 0; idx < data.size(); ++idx)
+    {
+      data[idx] = static_cast<Number>(idx) * get_factor<Number>();
+    }
+}
+
+template <template <class...> class Container, typename Number>
+typename std::enable_if<
+  std::is_same<Container<Number>, FullMatrix<Number>>::value,
+  void>::type
+assign_data(Container<Number> &data)
+{
+  for (unsigned int row_idx = 0; row_idx < data.m(); ++row_idx)
+    {
+      for (unsigned int col_idx = 0; col_idx < data.n(); ++col_idx)
+        {
+          data[row_idx][col_idx] =
+            static_cast<Number>(row_idx * data.n() + col_idx) *
+            get_factor<Number>();
+        }
+    }
+}
+
+// This function tests parallel write and gets the group by reference
+template <template <class...> class Container, typename Number>
+void
+write_test(HDF5::Group &              root_group,
+           const std::vector<hsize_t> dataset_dimensions,
+           MPI_Comm                   mpi_communicator,
+           ConditionalOStream         pcout)
+{
+  AssertDimension(dataset_dimensions.size(), 2);
+
+  std::string container_name;
+  std::string type_name;
+
+  if (std::is_same<Container<Number>, std::vector<Number>>::value)
+    {
+      container_name = std::string("std::vector");
+    }
+  else if (std::is_same<Container<Number>, FullMatrix<Number>>::value)
+    {
+      container_name = std::string("FullMatrix");
+    }
+
+  if (std::is_same<Number, float>::value)
+    {
+      type_name = std::string("float");
+    }
+  else if (std::is_same<Number, double>::value)
+    {
+      type_name = std::string("double");
+    }
+  else if (std::is_same<Number, std::complex<float>>::value)
+    {
+      type_name = std::string("std::complex<float>");
+    }
+  else if (std::is_same<Number, std::complex<double>>::value)
+    {
+      type_name = std::string("std::complex<double>");
+    }
+  else if (std::is_same<Number, int>::value)
+    {
+      type_name = std::string("int");
+    }
+  else if (std::is_same<Number, unsigned int>::value)
+    {
+      type_name = std::string("unsigned int");
+    }
+
+  deallog << "Write tests for " << container_name << "<" << type_name << ">"
+          << " datasets" << std::endl;
+
+  auto group = root_group.create_group(container_name + "<" + type_name + ">");
+
+  {
+    std::string dataset_name("dataset_1");
+    auto        dataset =
+      group.create_dataset<Number>(dataset_name, dataset_dimensions);
+    dataset.check_io_mode(true);
+    deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.dimensions() << std::endl;
+    deallog << "Size " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.size() << std::endl;
+    deallog << "Rank " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.rank() << std::endl;
+    auto data = initialize_container<Container, Number>(dataset_dimensions);
+    assign_data(data);
+    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+      {
+        dataset.write(data);
+      }
+    else
+      {
+        dataset.template write_none<Number>();
+      }
+    deallog << "Sum " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << container_sum(data) << std::endl;
+    pcout << "IO mode " + dataset_name << " " << container_name << "<"
+          << type_name << ">"
+          << " (Write): " << dataset.template io_mode<std::string>()
+          << std::endl;
+    pcout << "Local no collective cause " + dataset_name << " "
+          << container_name << "<" << type_name << ">"
+          << " (Write): "
+          << dataset.template local_no_collective_cause<std::string>()
+          << std::endl;
+    pcout << "Global no collective cause " + dataset_name << " "
+          << container_name << "<" << type_name << ">"
+          << " (Write): "
+          << dataset.template global_no_collective_cause<std::string>()
+          << std::endl;
+  }
+
+  {
+    std::string dataset_name("dataset_2");
+    auto        dataset =
+      group.create_dataset<Number>(dataset_name, dataset_dimensions);
+    dataset.check_io_mode(true);
+    deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.dimensions() << std::endl;
+    deallog << "Size " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.size() << std::endl;
+    deallog << "Rank " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.rank() << std::endl;
+
+    std::vector<hsize_t> coordinates_a = {0,
+                                          0, // first point
+                                          0,
+                                          2, // second point
+                                          3,
+                                          4, // third point
+                                          25,
+                                          12}; // fourth point
+    std::vector<Number>  data_a        = {2, 3, 5, 6};
+
+    std::vector<hsize_t> coordinates_b = {5,
+                                          0, // first point
+                                          0,
+                                          4, // second point
+                                          5,
+                                          4, // third point
+                                          26,
+                                          12}; // fourth point
+    std::vector<Number>  data_b        = {9, 4, 7, 6};
+
+    std::vector<hsize_t> coordinates_c = {5,
+                                          7, // first point
+                                          1,
+                                          8, // second point
+                                          5,
+                                          5, // third point
+                                          27,
+                                          12, // fourth point
+                                          28,
+                                          29}; // fifth point
+    std::vector<Number>  data_c        = {2, 3, 5, 6, 3};
+
+    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+      {
+        dataset.write_selection(data_a, coordinates_a);
+      }
+    else if (Utilities::MPI::this_mpi_process(mpi_communicator) == 1)
+      {
+        dataset.write_selection(data_b, coordinates_b);
+      }
+    else if (Utilities::MPI::this_mpi_process(mpi_communicator) == 2)
+      {
+        dataset.write_selection(data_c, coordinates_c);
+      }
+    else
+      {
+        dataset.template write_none<Number>();
+      }
+    deallog << "Sum " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): "
+            << container_sum(data_a) + container_sum(data_b) +
+                 container_sum(data_c)
+            << std::endl;
+    pcout << "IO mode " + dataset_name << " " << container_name << "<"
+          << type_name << ">"
+          << " (Write): " << dataset.template io_mode<std::string>()
+          << std::endl;
+    pcout << "Local no collective cause " + dataset_name << " "
+          << container_name << "<" << type_name << ">"
+          << " (Write): "
+          << dataset.template local_no_collective_cause<std::string>()
+          << std::endl;
+    pcout << "Global no collective cause " + dataset_name << " "
+          << container_name << "<" << type_name << ">"
+          << " (Write): "
+          << dataset.template global_no_collective_cause<std::string>()
+          << std::endl;
+  }
+
+  {
+    // In this dataset, data conversion is tested. The test is only performed
+    // for float and double.
+    if (std::is_same<Number, float>::value)
+      {
+        std::string dataset_name("dataset_3");
+        auto        dataset =
+          group.create_dataset<Number>(dataset_name, dataset_dimensions);
+        dataset.check_io_mode(true);
+        deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Write): " << dataset.dimensions() << std::endl;
+        deallog << "Size " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Write): " << dataset.size() << std::endl;
+        deallog << "Rank " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Write): " << dataset.rank() << std::endl;
+        auto data = initialize_container<Container, double>(dataset_dimensions);
+        assign_data(data);
+        if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+          {
+            dataset.write(data);
+          }
+        else
+          {
+            dataset.template write_none<Number>();
+          }
+        deallog << "Sum " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Write): " << container_sum(data) << std::endl;
+      }
+    else if (std::is_same<Number, double>::value)
+      {
+        std::string dataset_name("dataset_3");
+        auto        dataset =
+          group.create_dataset<Number>(dataset_name, dataset_dimensions);
+        dataset.check_io_mode(true);
+        auto data = initialize_container<Container, float>(dataset_dimensions);
+        assign_data(data);
+        if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+          {
+            dataset.write(data);
+          }
+        else
+          {
+            dataset.template write_none<Number>();
+          }
+        deallog << "Sum " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Write): " << container_sum(data) << std::endl;
+        pcout << "IO mode " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Write): " << dataset.template io_mode<std::string>()
+              << std::endl;
+        pcout << "Local no collective cause " + dataset_name << " "
+              << container_name << "<" << type_name << ">"
+              << " (Write): "
+              << dataset.template local_no_collective_cause<std::string>()
+              << std::endl;
+        pcout << "Global no collective cause " + dataset_name << " "
+              << container_name << "<" << type_name << ">"
+              << " (Write): "
+              << dataset.template global_no_collective_cause<std::string>()
+              << std::endl;
+      }
+  }
+
+  {
+    std::string dataset_name("dataset_4");
+    auto        dataset =
+      group.create_dataset<Number>(dataset_name, dataset_dimensions);
+    dataset.check_io_mode(true);
+    deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.dimensions() << std::endl;
+    deallog << "Size " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.size() << std::endl;
+    deallog << "Rank " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << dataset.rank() << std::endl;
+    const std::vector<hsize_t> hyperslab_dimensions_a = {2, 5};
+    const std::vector<hsize_t> hyperslab_offset_a     = {0, 0};
+    auto                       hyperslab_data_a =
+      initialize_container<Container, Number>(hyperslab_dimensions_a);
+    assign_data(hyperslab_data_a);
+    const std::vector<hsize_t> hyperslab_dimensions_b = {1, 4};
+    const std::vector<hsize_t> hyperslab_offset_b     = {2, 0};
+    auto                       hyperslab_data_b =
+      initialize_container<Container, Number>(hyperslab_dimensions_b);
+    assign_data(hyperslab_data_b);
+    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+      {
+        dataset.write_hyperslab(hyperslab_data_a,
+                                hyperslab_offset_a,
+                                hyperslab_dimensions_a);
+      }
+    else if (Utilities::MPI::this_mpi_process(mpi_communicator) == 1)
+      {
+        dataset.write_hyperslab(hyperslab_data_b,
+                                hyperslab_offset_b,
+                                hyperslab_dimensions_b);
+      }
+    else
+      {
+        dataset.template write_none<Number>();
+      }
+
+    // Now let's do a second write operation to the dataset using the complex
+    // version of write_hyperslab()
+    const std::vector<hsize_t> hyperslab_dimensions_c = {6, 8};
+    const std::vector<hsize_t> hyperslab_offset_c     = {4, 0};
+    const std::vector<hsize_t> hyperslab_stride_c     = {4, 3};
+    const std::vector<hsize_t> hyperslab_count_c      = {2, 4};
+    const std::vector<hsize_t> hyperslab_block_c      = {3, 2};
+    auto                       hyperslab_data_c =
+      initialize_container<Container, Number>(hyperslab_dimensions_c);
+    assign_data(hyperslab_data_c);
+    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+      {
+        dataset.write_hyperslab(hyperslab_data_c,
+                                hyperslab_dimensions_c,
+                                hyperslab_offset_c,
+                                hyperslab_stride_c,
+                                hyperslab_count_c,
+                                hyperslab_block_c);
+      }
+    else
+      {
+        dataset.template write_none<Number>();
+      }
+
+    deallog << "Sum " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): "
+            << container_sum(hyperslab_data_a) +
+                 container_sum(hyperslab_data_b) +
+                 container_sum(hyperslab_data_c)
+            << std::endl;
+    deallog << "Hyperslab_a sum " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << container_sum(hyperslab_data_a) << std::endl;
+    deallog << "Hyperslab_b sum " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Write): " << container_sum(hyperslab_data_b) << std::endl;
+    pcout << "IO mode " + dataset_name << " " << container_name << "<"
+          << type_name << ">"
+          << " (Write): " << dataset.template io_mode<std::string>()
+          << std::endl;
+    pcout << "Local no collective cause " + dataset_name << " "
+          << container_name << "<" << type_name << ">"
+          << " (Write): "
+          << dataset.template local_no_collective_cause<std::string>()
+          << std::endl;
+    pcout << "Global no collective cause " + dataset_name << " "
+          << container_name << "<" << type_name << ">"
+          << " (Write): "
+          << dataset.template global_no_collective_cause<std::string>()
+          << std::endl;
+  }
+}
+
+
+// This function tests parallel read. Unlike write_test, this functions gets a
+// copy of the group
+template <template <class...> class Container, typename Number>
+void
+read_test(HDF5::Group        root_group,
+          MPI_Comm           mpi_communicator,
+          ConditionalOStream pcout)
+{
+  {
+    std::string container_name;
+    std::string type_name;
+
+    if (std::is_same<Container<Number>, std::vector<Number>>::value)
+      {
+        container_name = std::string("std::vector");
+      }
+    else if (std::is_same<Container<Number>, FullMatrix<Number>>::value)
+      {
+        container_name = std::string("FullMatrix");
+      }
+
+    if (std::is_same<Number, float>::value)
+      {
+        type_name = std::string("float");
+      }
+    else if (std::is_same<Number, double>::value)
+      {
+        type_name = std::string("double");
+      }
+    else if (std::is_same<Number, std::complex<float>>::value)
+      {
+        type_name = std::string("std::complex<float>");
+      }
+    else if (std::is_same<Number, std::complex<double>>::value)
+      {
+        type_name = std::string("std::complex<double>");
+      }
+    else if (std::is_same<Number, int>::value)
+      {
+        type_name = std::string("int");
+      }
+    else if (std::is_same<Number, unsigned int>::value)
+      {
+        type_name = std::string("unsigned int");
+      }
+
+    deallog << "Read tests for " << container_name << "<" << type_name << ">"
+            << " datasets" << std::endl;
+
+    auto group = root_group.group(container_name + "<" + type_name + ">");
+
+    {
+      std::string dataset_name("dataset_1");
+      auto        dataset = group.dataset(dataset_name);
+      dataset.check_io_mode(true);
+      deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.dimensions() << std::endl;
+      deallog << "Size " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.size() << std::endl;
+      deallog << "Rank " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.rank() << std::endl;
+      Container<Number> data = dataset.read<Container, Number>();
+      deallog << "Sum " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << container_sum(data) << std::endl;
+      pcout << "IO mode " + dataset_name << " " << container_name << "<"
+            << type_name << ">"
+            << " (Read): " << dataset.template io_mode<std::string>()
+            << std::endl;
+      pcout << "Local no collective cause " + dataset_name << " "
+            << container_name << "<" << type_name << ">"
+            << " (Read): "
+            << dataset.template local_no_collective_cause<std::string>()
+            << std::endl;
+      pcout << "Global no collective cause " + dataset_name << " "
+            << container_name << "<" << type_name << ">"
+            << " (Read): "
+            << dataset.template global_no_collective_cause<std::string>()
+            << std::endl;
+    }
+
+    {
+      std::string dataset_name("dataset_2");
+      auto        dataset = group.dataset(dataset_name);
+      dataset.check_io_mode(true);
+      deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.dimensions() << std::endl;
+      deallog << "Size " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.size() << std::endl;
+      deallog << "Rank " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.rank() << std::endl;
+      {
+        Container<Number> data = dataset.read<Container, Number>();
+        deallog << "Sum " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << container_sum(data) << std::endl;
+        pcout << "IO mode " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.template io_mode<std::string>()
+              << std::endl;
+        pcout << "Local no collective cause " + dataset_name << " "
+              << container_name << "<" << type_name << ">"
+              << " (Read): "
+              << dataset.template local_no_collective_cause<std::string>()
+              << std::endl;
+        pcout << "Global no collective cause " + dataset_name << " "
+              << container_name << "<" << type_name << ">"
+              << " (Read): "
+              << dataset.template global_no_collective_cause<std::string>()
+              << std::endl;
+      }
+
+      {
+        std::vector<hsize_t> coordinates_a = {0,
+                                              0, // first point
+                                              0,
+                                              2, // second point
+                                              3,
+                                              4, // third point
+                                              25,
+                                              12}; // fourth point
+        auto data_a = dataset.template read_selection<Number>(coordinates_a);
+        deallog << "Selection " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << data_a[0] << ", " << data_a[1] << ", "
+                << data_a[2] << ", " << data_a[3] << std::endl;
+        pcout << "IO mode " + dataset_name << " " << container_name << "<"
+              << type_name << ">"
+              << " (Read): " << dataset.template io_mode<std::string>()
+              << std::endl;
+        pcout << "Local no collective cause " + dataset_name << " "
+              << container_name << "<" << type_name << ">"
+              << " (Read): "
+              << dataset.template local_no_collective_cause<std::string>()
+              << std::endl;
+        pcout << "Global no collective cause " + dataset_name << " "
+              << container_name << "<" << type_name << ">"
+              << " (Read): "
+              << dataset.template global_no_collective_cause<std::string>()
+              << std::endl;
+      }
+    }
+
+    {
+      // In this test data conversion is tested. The dataset only exists for
+      // float and double.
+      if (std::is_same<Number, float>::value ||
+          std::is_same<Number, double>::value)
+        {
+          std::string dataset_name("dataset_3");
+          auto        dataset = group.dataset(dataset_name);
+          dataset.check_io_mode(true);
+          deallog << "Dimensions " + dataset_name << " " << container_name
+                  << "<" << type_name << ">"
+                  << " (Read): " << dataset.dimensions() << std::endl;
+          deallog << "Size " + dataset_name << " " << container_name << "<"
+                  << type_name << ">"
+                  << " (Read): " << dataset.size() << std::endl;
+          deallog << "Rank " + dataset_name << " " << container_name << "<"
+                  << type_name << ">"
+                  << " (Read): " << dataset.rank() << std::endl;
+          Container<Number> data = dataset.read<Container, Number>();
+          deallog << "Sum " + dataset_name << " " << container_name << "<"
+                  << type_name << ">"
+                  << " (Read): " << container_sum(data) << std::endl;
+          pcout << "IO mode " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.template io_mode<std::string>()
+                << std::endl;
+          pcout << "Local no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template local_no_collective_cause<std::string>()
+                << std::endl;
+          pcout << "Global no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template global_no_collective_cause<std::string>()
+                << std::endl;
+        }
+
+      {
+        std::string dataset_name("dataset_4");
+        auto        dataset = group.dataset(dataset_name);
+        dataset.check_io_mode(true);
+        deallog << "Dimensions " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.dimensions() << std::endl;
+        deallog << "Size " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.size() << std::endl;
+        deallog << "Rank " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.rank() << std::endl;
+        {
+          Container<Number> data = dataset.read<Container, Number>();
+          deallog << "Sum " + dataset_name << " " << container_name << "<"
+                  << type_name << ">"
+                  << " (Read): " << container_sum(data) << std::endl;
+          pcout << "IO mode " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.template io_mode<std::string>()
+                << std::endl;
+          pcout << "Local no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template local_no_collective_cause<std::string>()
+                << std::endl;
+          pcout << "Global no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template global_no_collective_cause<std::string>()
+                << std::endl;
+        }
+
+        {
+          const std::vector<hsize_t> hyperslab_offset_a = {0, 0};
+          const std::vector<hsize_t> hyperslab_count_a  = {2, 5};
+          auto                       data_a =
+            dataset.read_hyperslab<Container, Number>(hyperslab_offset_a,
+                                                      hyperslab_count_a);
+          deallog << "Hyperslab_a sum " + dataset_name << " " << container_name
+                  << "<" << type_name << ">"
+                  << " (Read): " << container_sum(data_a) << std::endl;
+          pcout << "IO mode " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.template io_mode<std::string>()
+                << std::endl;
+          pcout << "Local no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template local_no_collective_cause<std::string>()
+                << std::endl;
+          pcout << "Global no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template global_no_collective_cause<std::string>()
+                << std::endl;
+        }
+
+        {
+          const std::vector<hsize_t> hyperslab_offset_b = {2, 0};
+          const std::vector<hsize_t> hyperslab_count_b  = {1, 4};
+          Container<Number>          data_b;
+          // This loop is used to test read_none(). At the end of the loop every
+          // MPI process will have read data_b
+          for (unsigned int mpi_idx = 0;
+               mpi_idx < Utilities::MPI::n_mpi_processes(mpi_communicator);
+               ++mpi_idx)
+            {
+              if (Utilities::MPI::this_mpi_process(mpi_communicator) == mpi_idx)
+                {
+                  data_b = dataset.read_hyperslab<Container, Number>(
+                    hyperslab_offset_b, hyperslab_count_b);
+                }
+              else
+                {
+                  dataset.read_none<Number>();
+                }
+            }
+          deallog << "Hyperslab_b sum " + dataset_name << " " << container_name
+                  << "<" << type_name << ">"
+                  << " (Read): " << container_sum(data_b) << std::endl;
+          pcout << "IO mode " + dataset_name << " " << container_name << "<"
+                << type_name << ">"
+                << " (Read): " << dataset.template io_mode<std::string>()
+                << std::endl;
+          pcout << "Local no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template local_no_collective_cause<std::string>()
+                << std::endl;
+          pcout << "Global no collective cause " + dataset_name << " "
+                << container_name << "<" << type_name << ">"
+                << " (Read): "
+                << dataset.template global_no_collective_cause<std::string>()
+                << std::endl;
+        }
+      }
+    }
+  }
+}
+
+
+int
+main(int argc, char **argv)
+{
+  initlog();
+
+  try
+    {
+      Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+
+      MPI_Comm mpi_communicator = MPI_COMM_WORLD;
+
+      ConditionalOStream pcout(
+        std::cout, Utilities::MPI::this_mpi_process(mpi_communicator) == 0);
+
+      std::string                filename           = "test.h5";
+      const std::vector<hsize_t> dataset_dimensions = {50, 30};
+
+      {
+        HDF5::File data_file(filename,
+                             mpi_communicator,
+                             HDF5::File::Mode::create);
+
+        write_test<std::vector, float>(data_file,
+                                       dataset_dimensions,
+                                       mpi_communicator,
+                                       pcout);
+        write_test<std::vector, double>(data_file,
+                                        dataset_dimensions,
+                                        mpi_communicator,
+                                        pcout);
+        write_test<std::vector, std::complex<float>>(data_file,
+                                                     dataset_dimensions,
+                                                     mpi_communicator,
+                                                     pcout);
+        write_test<std::vector, std::complex<double>>(data_file,
+                                                      dataset_dimensions,
+                                                      mpi_communicator,
+                                                      pcout);
+        write_test<std::vector, int>(data_file,
+                                     dataset_dimensions,
+                                     mpi_communicator,
+                                     pcout);
+        write_test<std::vector, unsigned int>(data_file,
+                                              dataset_dimensions,
+                                              mpi_communicator,
+                                              pcout);
+        write_test<FullMatrix, float>(data_file,
+                                      dataset_dimensions,
+                                      mpi_communicator,
+                                      pcout);
+        write_test<FullMatrix, double>(data_file,
+                                       dataset_dimensions,
+                                       mpi_communicator,
+                                       pcout);
+        write_test<FullMatrix, std::complex<float>>(data_file,
+                                                    dataset_dimensions,
+                                                    mpi_communicator,
+                                                    pcout);
+        write_test<FullMatrix, std::complex<double>>(data_file,
+                                                     dataset_dimensions,
+                                                     mpi_communicator,
+                                                     pcout);
+      }
+
+      {
+        HDF5::File data_file(filename,
+                             mpi_communicator,
+                             HDF5::File::Mode::open);
+        read_test<std::vector, float>(data_file, mpi_communicator, pcout);
+        read_test<std::vector, double>(data_file, mpi_communicator, pcout);
+        read_test<std::vector, std::complex<float>>(data_file,
+                                                    mpi_communicator,
+                                                    pcout);
+        read_test<std::vector, std::complex<double>>(data_file,
+                                                     mpi_communicator,
+                                                     pcout);
+        read_test<std::vector, int>(data_file, mpi_communicator, pcout);
+        read_test<std::vector, unsigned int>(data_file,
+                                             mpi_communicator,
+                                             pcout);
+        read_test<FullMatrix, float>(data_file, mpi_communicator, pcout);
+        read_test<FullMatrix, double>(data_file, mpi_communicator, pcout);
+        read_test<FullMatrix, std::complex<float>>(data_file,
+                                                   mpi_communicator,
+                                                   pcout);
+        read_test<FullMatrix, std::complex<double>>(data_file,
+                                                    mpi_communicator,
+                                                    pcout);
+      }
+    }
+  catch (std::exception &exc)
+    {
+      std::cerr << std::endl
+                << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Exception on processing: " << std::endl
+                << exc.what() << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+
+      return 1;
+    }
+  catch (...)
+    {
+      std::cerr << std::endl
+                << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Unknown exception!" << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      return 1;
+    };
+}
diff --git a/tests/base/hdf5_03.with_hdf5=true.mpirun=1.output b/tests/base/hdf5_03.with_hdf5=true.mpirun=1.output
new file mode 100644
index 0000000000..3a0a81c6d7
--- /dev/null
+++ b/tests/base/hdf5_03.with_hdf5=true.mpirun=1.output
@@ -0,0 +1,337 @@
+
+DEAL::Write tests for std::vector<float> datasets
+DEAL::Dimensions dataset_1 std::vector<float> (Write): 50 30
+DEAL::Size dataset_1 std::vector<float> (Write): 1500
+DEAL::Rank dataset_1 std::vector<float> (Write): 2
+DEAL::Sum dataset_1 std::vector<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<float> (Write): 50 30
+DEAL::Size dataset_2 std::vector<float> (Write): 1500
+DEAL::Rank dataset_2 std::vector<float> (Write): 2
+DEAL::Sum dataset_2 std::vector<float> (Write): 61.0000
+DEAL::Dimensions dataset_3 std::vector<float> (Write): 50 30
+DEAL::Size dataset_3 std::vector<float> (Write): 1500
+DEAL::Rank dataset_3 std::vector<float> (Write): 2
+DEAL::Sum dataset_3 std::vector<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<float> (Write): 50 30
+DEAL::Size dataset_4 std::vector<float> (Write): 1500
+DEAL::Rank dataset_4 std::vector<float> (Write): 2
+DEAL::Sum dataset_4 std::vector<float> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<float> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<float> (Write): 6.00000
+DEAL::Write tests for std::vector<double> datasets
+DEAL::Dimensions dataset_1 std::vector<double> (Write): 50 30
+DEAL::Size dataset_1 std::vector<double> (Write): 1500
+DEAL::Rank dataset_1 std::vector<double> (Write): 2
+DEAL::Sum dataset_1 std::vector<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<double> (Write): 50 30
+DEAL::Size dataset_2 std::vector<double> (Write): 1500
+DEAL::Rank dataset_2 std::vector<double> (Write): 2
+DEAL::Sum dataset_2 std::vector<double> (Write): 61.0000
+DEAL::Sum dataset_3 std::vector<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<double> (Write): 50 30
+DEAL::Size dataset_4 std::vector<double> (Write): 1500
+DEAL::Rank dataset_4 std::vector<double> (Write): 2
+DEAL::Sum dataset_4 std::vector<double> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<double> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<double> (Write): 6.00000
+DEAL::Write tests for std::vector<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<float>> (Write): 2
+DEAL::Sum dataset_1 std::vector<std::complex<float>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<float>> (Write): 2
+DEAL::Sum dataset_2 std::vector<std::complex<float>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<float>> (Write): 2
+DEAL::Sum dataset_4 std::vector<std::complex<float>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<float>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<float>> (Write): (6.00000,6.00000)
+DEAL::Write tests for std::vector<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<double>> (Write): 2
+DEAL::Sum dataset_1 std::vector<std::complex<double>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<double>> (Write): 2
+DEAL::Sum dataset_2 std::vector<std::complex<double>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<double>> (Write): 2
+DEAL::Sum dataset_4 std::vector<std::complex<double>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<double>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<double>> (Write): (6.00000,6.00000)
+DEAL::Write tests for std::vector<int> datasets
+DEAL::Dimensions dataset_1 std::vector<int> (Write): 50 30
+DEAL::Size dataset_1 std::vector<int> (Write): 1500
+DEAL::Rank dataset_1 std::vector<int> (Write): 2
+DEAL::Sum dataset_1 std::vector<int> (Write): 1124250
+DEAL::Dimensions dataset_2 std::vector<int> (Write): 50 30
+DEAL::Size dataset_2 std::vector<int> (Write): 1500
+DEAL::Rank dataset_2 std::vector<int> (Write): 2
+DEAL::Sum dataset_2 std::vector<int> (Write): 61
+DEAL::Dimensions dataset_4 std::vector<int> (Write): 50 30
+DEAL::Size dataset_4 std::vector<int> (Write): 1500
+DEAL::Rank dataset_4 std::vector<int> (Write): 2
+DEAL::Sum dataset_4 std::vector<int> (Write): 1179
+DEAL::Hyperslab_a sum dataset_4 std::vector<int> (Write): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<int> (Write): 6
+DEAL::Write tests for std::vector<unsigned int> datasets
+DEAL::Dimensions dataset_1 std::vector<unsigned int> (Write): 50 30
+DEAL::Size dataset_1 std::vector<unsigned int> (Write): 1500
+DEAL::Rank dataset_1 std::vector<unsigned int> (Write): 2
+DEAL::Sum dataset_1 std::vector<unsigned int> (Write): 1124250
+DEAL::Dimensions dataset_2 std::vector<unsigned int> (Write): 50 30
+DEAL::Size dataset_2 std::vector<unsigned int> (Write): 1500
+DEAL::Rank dataset_2 std::vector<unsigned int> (Write): 2
+DEAL::Sum dataset_2 std::vector<unsigned int> (Write): 61
+DEAL::Dimensions dataset_4 std::vector<unsigned int> (Write): 50 30
+DEAL::Size dataset_4 std::vector<unsigned int> (Write): 1500
+DEAL::Rank dataset_4 std::vector<unsigned int> (Write): 2
+DEAL::Sum dataset_4 std::vector<unsigned int> (Write): 1179
+DEAL::Hyperslab_a sum dataset_4 std::vector<unsigned int> (Write): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<unsigned int> (Write): 6
+DEAL::Write tests for FullMatrix<float> datasets
+DEAL::Dimensions dataset_1 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<float> (Write): 61.0000
+DEAL::Dimensions dataset_3 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_3 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_3 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_3 FullMatrix<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<float> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<float> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<float> (Write): 6.00000
+DEAL::Write tests for FullMatrix<double> datasets
+DEAL::Dimensions dataset_1 FullMatrix<double> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<double> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<double> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<double> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<double> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<double> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<double> (Write): 61.0000
+DEAL::Sum dataset_3 FullMatrix<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<double> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<double> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<double> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<double> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<double> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<double> (Write): 6.00000
+DEAL::Write tests for FullMatrix<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<float>> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<float>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<float>> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<float>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<float>> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<float>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<float>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<float>> (Write): (6.00000,6.00000)
+DEAL::Write tests for FullMatrix<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<double>> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<double>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<double>> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<double>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<double>> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<double>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<double>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<double>> (Write): (6.00000,6.00000)
+DEAL::Read tests for std::vector<float> datasets
+DEAL::Dimensions dataset_1 std::vector<float> (Read): 50 30
+DEAL::Size dataset_1 std::vector<float> (Read): 1500
+DEAL::Rank dataset_1 std::vector<float> (Read): 2
+DEAL::Sum dataset_1 std::vector<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<float> (Read): 50 30
+DEAL::Size dataset_2 std::vector<float> (Read): 1500
+DEAL::Rank dataset_2 std::vector<float> (Read): 2
+DEAL::Sum dataset_2 std::vector<float> (Read): 16.0000
+DEAL::Selection dataset_2 std::vector<float> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 std::vector<float> (Read): 50 30
+DEAL::Size dataset_3 std::vector<float> (Read): 1500
+DEAL::Rank dataset_3 std::vector<float> (Read): 2
+DEAL::Sum dataset_3 std::vector<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<float> (Read): 50 30
+DEAL::Size dataset_4 std::vector<float> (Read): 1500
+DEAL::Rank dataset_4 std::vector<float> (Read): 2
+DEAL::Sum dataset_4 std::vector<float> (Read): 1173.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<float> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<float> (Read): 0.00000
+DEAL::Read tests for std::vector<double> datasets
+DEAL::Dimensions dataset_1 std::vector<double> (Read): 50 30
+DEAL::Size dataset_1 std::vector<double> (Read): 1500
+DEAL::Rank dataset_1 std::vector<double> (Read): 2
+DEAL::Sum dataset_1 std::vector<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<double> (Read): 50 30
+DEAL::Size dataset_2 std::vector<double> (Read): 1500
+DEAL::Rank dataset_2 std::vector<double> (Read): 2
+DEAL::Sum dataset_2 std::vector<double> (Read): 16.0000
+DEAL::Selection dataset_2 std::vector<double> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 std::vector<double> (Read): 50 30
+DEAL::Size dataset_3 std::vector<double> (Read): 1500
+DEAL::Rank dataset_3 std::vector<double> (Read): 2
+DEAL::Sum dataset_3 std::vector<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<double> (Read): 50 30
+DEAL::Size dataset_4 std::vector<double> (Read): 1500
+DEAL::Rank dataset_4 std::vector<double> (Read): 2
+DEAL::Sum dataset_4 std::vector<double> (Read): 1173.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<double> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<double> (Read): 0.00000
+DEAL::Read tests for std::vector<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<float>> (Read): 2
+DEAL::Sum dataset_1 std::vector<std::complex<float>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<float>> (Read): 2
+DEAL::Sum dataset_2 std::vector<std::complex<float>> (Read): (16.0000,0.00000)
+DEAL::Selection dataset_2 std::vector<std::complex<float>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<float>> (Read): 2
+DEAL::Sum dataset_4 std::vector<std::complex<float>> (Read): (1173.00,1173.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<float>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<float>> (Read): (0.00000,0.00000)
+DEAL::Read tests for std::vector<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<double>> (Read): 2
+DEAL::Sum dataset_1 std::vector<std::complex<double>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<double>> (Read): 2
+DEAL::Sum dataset_2 std::vector<std::complex<double>> (Read): (16.0000,0.00000)
+DEAL::Selection dataset_2 std::vector<std::complex<double>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<double>> (Read): 2
+DEAL::Sum dataset_4 std::vector<std::complex<double>> (Read): (1173.00,1173.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<double>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<double>> (Read): (0.00000,0.00000)
+DEAL::Read tests for std::vector<int> datasets
+DEAL::Dimensions dataset_1 std::vector<int> (Read): 50 30
+DEAL::Size dataset_1 std::vector<int> (Read): 1500
+DEAL::Rank dataset_1 std::vector<int> (Read): 2
+DEAL::Sum dataset_1 std::vector<int> (Read): 1124250
+DEAL::Dimensions dataset_2 std::vector<int> (Read): 50 30
+DEAL::Size dataset_2 std::vector<int> (Read): 1500
+DEAL::Rank dataset_2 std::vector<int> (Read): 2
+DEAL::Sum dataset_2 std::vector<int> (Read): 16
+DEAL::Selection dataset_2 std::vector<int> (Read): 2, 3, 5, 6
+DEAL::Dimensions dataset_4 std::vector<int> (Read): 50 30
+DEAL::Size dataset_4 std::vector<int> (Read): 1500
+DEAL::Rank dataset_4 std::vector<int> (Read): 2
+DEAL::Sum dataset_4 std::vector<int> (Read): 1173
+DEAL::Hyperslab_a sum dataset_4 std::vector<int> (Read): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<int> (Read): 0
+DEAL::Read tests for std::vector<unsigned int> datasets
+DEAL::Dimensions dataset_1 std::vector<unsigned int> (Read): 50 30
+DEAL::Size dataset_1 std::vector<unsigned int> (Read): 1500
+DEAL::Rank dataset_1 std::vector<unsigned int> (Read): 2
+DEAL::Sum dataset_1 std::vector<unsigned int> (Read): 1124250
+DEAL::Dimensions dataset_2 std::vector<unsigned int> (Read): 50 30
+DEAL::Size dataset_2 std::vector<unsigned int> (Read): 1500
+DEAL::Rank dataset_2 std::vector<unsigned int> (Read): 2
+DEAL::Sum dataset_2 std::vector<unsigned int> (Read): 16
+DEAL::Selection dataset_2 std::vector<unsigned int> (Read): 2, 3, 5, 6
+DEAL::Dimensions dataset_4 std::vector<unsigned int> (Read): 50 30
+DEAL::Size dataset_4 std::vector<unsigned int> (Read): 1500
+DEAL::Rank dataset_4 std::vector<unsigned int> (Read): 2
+DEAL::Sum dataset_4 std::vector<unsigned int> (Read): 1173
+DEAL::Hyperslab_a sum dataset_4 std::vector<unsigned int> (Read): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<unsigned int> (Read): 0
+DEAL::Read tests for FullMatrix<float> datasets
+DEAL::Dimensions dataset_1 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<float> (Read): 16.0000
+DEAL::Selection dataset_2 FullMatrix<float> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_3 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_3 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_3 FullMatrix<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<float> (Read): 1173.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<float> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<float> (Read): 0.00000
+DEAL::Read tests for FullMatrix<double> datasets
+DEAL::Dimensions dataset_1 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<double> (Read): 16.0000
+DEAL::Selection dataset_2 FullMatrix<double> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_3 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_3 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_3 FullMatrix<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<double> (Read): 1173.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<double> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<double> (Read): 0.00000
+DEAL::Read tests for FullMatrix<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<float>> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<float>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<float>> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<float>> (Read): (16.0000,0.00000)
+DEAL::Selection dataset_2 FullMatrix<std::complex<float>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<float>> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<float>> (Read): (1173.00,1173.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<float>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<float>> (Read): (0.00000,0.00000)
+DEAL::Read tests for FullMatrix<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<double>> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<double>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<double>> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<double>> (Read): (16.0000,0.00000)
+DEAL::Selection dataset_2 FullMatrix<std::complex<double>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<double>> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<double>> (Read): (1173.00,1173.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<double>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<double>> (Read): (0.00000,0.00000)
diff --git a/tests/base/hdf5_03.with_hdf5=true.mpirun=4.output b/tests/base/hdf5_03.with_hdf5=true.mpirun=4.output
new file mode 100644
index 0000000000..ec49502f5e
--- /dev/null
+++ b/tests/base/hdf5_03.with_hdf5=true.mpirun=4.output
@@ -0,0 +1,337 @@
+
+DEAL::Write tests for std::vector<float> datasets
+DEAL::Dimensions dataset_1 std::vector<float> (Write): 50 30
+DEAL::Size dataset_1 std::vector<float> (Write): 1500
+DEAL::Rank dataset_1 std::vector<float> (Write): 2
+DEAL::Sum dataset_1 std::vector<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<float> (Write): 50 30
+DEAL::Size dataset_2 std::vector<float> (Write): 1500
+DEAL::Rank dataset_2 std::vector<float> (Write): 2
+DEAL::Sum dataset_2 std::vector<float> (Write): 61.0000
+DEAL::Dimensions dataset_3 std::vector<float> (Write): 50 30
+DEAL::Size dataset_3 std::vector<float> (Write): 1500
+DEAL::Rank dataset_3 std::vector<float> (Write): 2
+DEAL::Sum dataset_3 std::vector<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<float> (Write): 50 30
+DEAL::Size dataset_4 std::vector<float> (Write): 1500
+DEAL::Rank dataset_4 std::vector<float> (Write): 2
+DEAL::Sum dataset_4 std::vector<float> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<float> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<float> (Write): 6.00000
+DEAL::Write tests for std::vector<double> datasets
+DEAL::Dimensions dataset_1 std::vector<double> (Write): 50 30
+DEAL::Size dataset_1 std::vector<double> (Write): 1500
+DEAL::Rank dataset_1 std::vector<double> (Write): 2
+DEAL::Sum dataset_1 std::vector<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<double> (Write): 50 30
+DEAL::Size dataset_2 std::vector<double> (Write): 1500
+DEAL::Rank dataset_2 std::vector<double> (Write): 2
+DEAL::Sum dataset_2 std::vector<double> (Write): 61.0000
+DEAL::Sum dataset_3 std::vector<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<double> (Write): 50 30
+DEAL::Size dataset_4 std::vector<double> (Write): 1500
+DEAL::Rank dataset_4 std::vector<double> (Write): 2
+DEAL::Sum dataset_4 std::vector<double> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<double> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<double> (Write): 6.00000
+DEAL::Write tests for std::vector<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<float>> (Write): 2
+DEAL::Sum dataset_1 std::vector<std::complex<float>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<float>> (Write): 2
+DEAL::Sum dataset_2 std::vector<std::complex<float>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<float>> (Write): 2
+DEAL::Sum dataset_4 std::vector<std::complex<float>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<float>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<float>> (Write): (6.00000,6.00000)
+DEAL::Write tests for std::vector<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<double>> (Write): 2
+DEAL::Sum dataset_1 std::vector<std::complex<double>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<double>> (Write): 2
+DEAL::Sum dataset_2 std::vector<std::complex<double>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<double>> (Write): 2
+DEAL::Sum dataset_4 std::vector<std::complex<double>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<double>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<double>> (Write): (6.00000,6.00000)
+DEAL::Write tests for std::vector<int> datasets
+DEAL::Dimensions dataset_1 std::vector<int> (Write): 50 30
+DEAL::Size dataset_1 std::vector<int> (Write): 1500
+DEAL::Rank dataset_1 std::vector<int> (Write): 2
+DEAL::Sum dataset_1 std::vector<int> (Write): 1124250
+DEAL::Dimensions dataset_2 std::vector<int> (Write): 50 30
+DEAL::Size dataset_2 std::vector<int> (Write): 1500
+DEAL::Rank dataset_2 std::vector<int> (Write): 2
+DEAL::Sum dataset_2 std::vector<int> (Write): 61
+DEAL::Dimensions dataset_4 std::vector<int> (Write): 50 30
+DEAL::Size dataset_4 std::vector<int> (Write): 1500
+DEAL::Rank dataset_4 std::vector<int> (Write): 2
+DEAL::Sum dataset_4 std::vector<int> (Write): 1179
+DEAL::Hyperslab_a sum dataset_4 std::vector<int> (Write): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<int> (Write): 6
+DEAL::Write tests for std::vector<unsigned int> datasets
+DEAL::Dimensions dataset_1 std::vector<unsigned int> (Write): 50 30
+DEAL::Size dataset_1 std::vector<unsigned int> (Write): 1500
+DEAL::Rank dataset_1 std::vector<unsigned int> (Write): 2
+DEAL::Sum dataset_1 std::vector<unsigned int> (Write): 1124250
+DEAL::Dimensions dataset_2 std::vector<unsigned int> (Write): 50 30
+DEAL::Size dataset_2 std::vector<unsigned int> (Write): 1500
+DEAL::Rank dataset_2 std::vector<unsigned int> (Write): 2
+DEAL::Sum dataset_2 std::vector<unsigned int> (Write): 61
+DEAL::Dimensions dataset_4 std::vector<unsigned int> (Write): 50 30
+DEAL::Size dataset_4 std::vector<unsigned int> (Write): 1500
+DEAL::Rank dataset_4 std::vector<unsigned int> (Write): 2
+DEAL::Sum dataset_4 std::vector<unsigned int> (Write): 1179
+DEAL::Hyperslab_a sum dataset_4 std::vector<unsigned int> (Write): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<unsigned int> (Write): 6
+DEAL::Write tests for FullMatrix<float> datasets
+DEAL::Dimensions dataset_1 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<float> (Write): 61.0000
+DEAL::Dimensions dataset_3 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_3 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_3 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_3 FullMatrix<float> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<float> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<float> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<float> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<float> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<float> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<float> (Write): 6.00000
+DEAL::Write tests for FullMatrix<double> datasets
+DEAL::Dimensions dataset_1 FullMatrix<double> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<double> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<double> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<double> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<double> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<double> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<double> (Write): 61.0000
+DEAL::Sum dataset_3 FullMatrix<double> (Write): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<double> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<double> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<double> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<double> (Write): 1179.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<double> (Write): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<double> (Write): 6.00000
+DEAL::Write tests for FullMatrix<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<float>> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<float>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<float>> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<float>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<float>> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<float>> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<float>> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<float>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<float>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<float>> (Write): (6.00000,6.00000)
+DEAL::Write tests for FullMatrix<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<double>> (Write): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<double>> (Write): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<double>> (Write): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<double>> (Write): (61.0000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<double>> (Write): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<double>> (Write): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<double>> (Write): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<double>> (Write): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<double>> (Write): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<double>> (Write): (6.00000,6.00000)
+DEAL::Read tests for std::vector<float> datasets
+DEAL::Dimensions dataset_1 std::vector<float> (Read): 50 30
+DEAL::Size dataset_1 std::vector<float> (Read): 1500
+DEAL::Rank dataset_1 std::vector<float> (Read): 2
+DEAL::Sum dataset_1 std::vector<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<float> (Read): 50 30
+DEAL::Size dataset_2 std::vector<float> (Read): 1500
+DEAL::Rank dataset_2 std::vector<float> (Read): 2
+DEAL::Sum dataset_2 std::vector<float> (Read): 61.0000
+DEAL::Selection dataset_2 std::vector<float> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 std::vector<float> (Read): 50 30
+DEAL::Size dataset_3 std::vector<float> (Read): 1500
+DEAL::Rank dataset_3 std::vector<float> (Read): 2
+DEAL::Sum dataset_3 std::vector<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<float> (Read): 50 30
+DEAL::Size dataset_4 std::vector<float> (Read): 1500
+DEAL::Rank dataset_4 std::vector<float> (Read): 2
+DEAL::Sum dataset_4 std::vector<float> (Read): 1179.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<float> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<float> (Read): 6.00000
+DEAL::Read tests for std::vector<double> datasets
+DEAL::Dimensions dataset_1 std::vector<double> (Read): 50 30
+DEAL::Size dataset_1 std::vector<double> (Read): 1500
+DEAL::Rank dataset_1 std::vector<double> (Read): 2
+DEAL::Sum dataset_1 std::vector<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 std::vector<double> (Read): 50 30
+DEAL::Size dataset_2 std::vector<double> (Read): 1500
+DEAL::Rank dataset_2 std::vector<double> (Read): 2
+DEAL::Sum dataset_2 std::vector<double> (Read): 61.0000
+DEAL::Selection dataset_2 std::vector<double> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 std::vector<double> (Read): 50 30
+DEAL::Size dataset_3 std::vector<double> (Read): 1500
+DEAL::Rank dataset_3 std::vector<double> (Read): 2
+DEAL::Sum dataset_3 std::vector<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 std::vector<double> (Read): 50 30
+DEAL::Size dataset_4 std::vector<double> (Read): 1500
+DEAL::Rank dataset_4 std::vector<double> (Read): 2
+DEAL::Sum dataset_4 std::vector<double> (Read): 1179.00
+DEAL::Hyperslab_a sum dataset_4 std::vector<double> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 std::vector<double> (Read): 6.00000
+DEAL::Read tests for std::vector<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<float>> (Read): 2
+DEAL::Sum dataset_1 std::vector<std::complex<float>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<float>> (Read): 2
+DEAL::Sum dataset_2 std::vector<std::complex<float>> (Read): (61.0000,0.00000)
+DEAL::Selection dataset_2 std::vector<std::complex<float>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<float>> (Read): 2
+DEAL::Sum dataset_4 std::vector<std::complex<float>> (Read): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<float>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<float>> (Read): (6.00000,6.00000)
+DEAL::Read tests for std::vector<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 std::vector<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_1 std::vector<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_1 std::vector<std::complex<double>> (Read): 2
+DEAL::Sum dataset_1 std::vector<std::complex<double>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 std::vector<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_2 std::vector<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_2 std::vector<std::complex<double>> (Read): 2
+DEAL::Sum dataset_2 std::vector<std::complex<double>> (Read): (61.0000,0.00000)
+DEAL::Selection dataset_2 std::vector<std::complex<double>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 std::vector<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_4 std::vector<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_4 std::vector<std::complex<double>> (Read): 2
+DEAL::Sum dataset_4 std::vector<std::complex<double>> (Read): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 std::vector<std::complex<double>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 std::vector<std::complex<double>> (Read): (6.00000,6.00000)
+DEAL::Read tests for std::vector<int> datasets
+DEAL::Dimensions dataset_1 std::vector<int> (Read): 50 30
+DEAL::Size dataset_1 std::vector<int> (Read): 1500
+DEAL::Rank dataset_1 std::vector<int> (Read): 2
+DEAL::Sum dataset_1 std::vector<int> (Read): 1124250
+DEAL::Dimensions dataset_2 std::vector<int> (Read): 50 30
+DEAL::Size dataset_2 std::vector<int> (Read): 1500
+DEAL::Rank dataset_2 std::vector<int> (Read): 2
+DEAL::Sum dataset_2 std::vector<int> (Read): 61
+DEAL::Selection dataset_2 std::vector<int> (Read): 2, 3, 5, 6
+DEAL::Dimensions dataset_4 std::vector<int> (Read): 50 30
+DEAL::Size dataset_4 std::vector<int> (Read): 1500
+DEAL::Rank dataset_4 std::vector<int> (Read): 2
+DEAL::Sum dataset_4 std::vector<int> (Read): 1179
+DEAL::Hyperslab_a sum dataset_4 std::vector<int> (Read): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<int> (Read): 6
+DEAL::Read tests for std::vector<unsigned int> datasets
+DEAL::Dimensions dataset_1 std::vector<unsigned int> (Read): 50 30
+DEAL::Size dataset_1 std::vector<unsigned int> (Read): 1500
+DEAL::Rank dataset_1 std::vector<unsigned int> (Read): 2
+DEAL::Sum dataset_1 std::vector<unsigned int> (Read): 1124250
+DEAL::Dimensions dataset_2 std::vector<unsigned int> (Read): 50 30
+DEAL::Size dataset_2 std::vector<unsigned int> (Read): 1500
+DEAL::Rank dataset_2 std::vector<unsigned int> (Read): 2
+DEAL::Sum dataset_2 std::vector<unsigned int> (Read): 61
+DEAL::Selection dataset_2 std::vector<unsigned int> (Read): 2, 3, 5, 6
+DEAL::Dimensions dataset_4 std::vector<unsigned int> (Read): 50 30
+DEAL::Size dataset_4 std::vector<unsigned int> (Read): 1500
+DEAL::Rank dataset_4 std::vector<unsigned int> (Read): 2
+DEAL::Sum dataset_4 std::vector<unsigned int> (Read): 1179
+DEAL::Hyperslab_a sum dataset_4 std::vector<unsigned int> (Read): 45
+DEAL::Hyperslab_b sum dataset_4 std::vector<unsigned int> (Read): 6
+DEAL::Read tests for FullMatrix<float> datasets
+DEAL::Dimensions dataset_1 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<float> (Read): 61.0000
+DEAL::Selection dataset_2 FullMatrix<float> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_3 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_3 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_3 FullMatrix<float> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<float> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<float> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<float> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<float> (Read): 1179.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<float> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<float> (Read): 6.00000
+DEAL::Read tests for FullMatrix<double> datasets
+DEAL::Dimensions dataset_1 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_2 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<double> (Read): 61.0000
+DEAL::Selection dataset_2 FullMatrix<double> (Read): 2.00000, 3.00000, 5.00000, 6.00000
+DEAL::Dimensions dataset_3 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_3 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_3 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_3 FullMatrix<double> (Read): 1.12425e+06
+DEAL::Dimensions dataset_4 FullMatrix<double> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<double> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<double> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<double> (Read): 1179.00
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<double> (Read): 45.0000
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<double> (Read): 6.00000
+DEAL::Read tests for FullMatrix<std::complex<float>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<float>> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<float>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<float>> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<float>> (Read): (61.0000,0.00000)
+DEAL::Selection dataset_2 FullMatrix<std::complex<float>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<float>> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<float>> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<float>> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<float>> (Read): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<float>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<float>> (Read): (6.00000,6.00000)
+DEAL::Read tests for FullMatrix<std::complex<double>> datasets
+DEAL::Dimensions dataset_1 FullMatrix<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_1 FullMatrix<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_1 FullMatrix<std::complex<double>> (Read): 2
+DEAL::Sum dataset_1 FullMatrix<std::complex<double>> (Read): (1.12425e+06,1.12425e+06)
+DEAL::Dimensions dataset_2 FullMatrix<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_2 FullMatrix<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_2 FullMatrix<std::complex<double>> (Read): 2
+DEAL::Sum dataset_2 FullMatrix<std::complex<double>> (Read): (61.0000,0.00000)
+DEAL::Selection dataset_2 FullMatrix<std::complex<double>> (Read): (2.00000,0.00000), (3.00000,0.00000), (5.00000,0.00000), (6.00000,0.00000)
+DEAL::Dimensions dataset_4 FullMatrix<std::complex<double>> (Read): 50 30
+DEAL::Size dataset_4 FullMatrix<std::complex<double>> (Read): 1500
+DEAL::Rank dataset_4 FullMatrix<std::complex<double>> (Read): 2
+DEAL::Sum dataset_4 FullMatrix<std::complex<double>> (Read): (1179.00,1179.00)
+DEAL::Hyperslab_a sum dataset_4 FullMatrix<std::complex<double>> (Read): (45.0000,45.0000)
+DEAL::Hyperslab_b sum dataset_4 FullMatrix<std::complex<double>> (Read): (6.00000,6.00000)
-- 
2.39.5