++

Author: PhilipDeegan

src/diagnostic/detail/vtk_types/fluid.hpp

@@ -57,9 +57,9 @@ void FluidDiagnosticWriter<H5Writer>::write(DiagnosticProperties& diagnostic)
                 std::string tree{"/ions/pop/" + pop.name() + "/"};
                 if (isActiveDiag(diagnostic, tree, "density"))
                     initializer.writeField(pop.particleDensity(), layout);
-                if (isActiveDiag(diagnostic, tree, "charge_density"))
+                else if (isActiveDiag(diagnostic, tree, "charge_density"))
                     initializer.writeField(pop.chargeDensity(), layout);
-                if (isActiveDiag(diagnostic, tree, "flux"))
+                else if (isActiveDiag(diagnostic, tree, "flux"))
                     initializer.template writeTensorField<1>(pop.flux(), layout);
             }
         }

src/diagnostic/detail/vtkh5_type_writer.hpp

@@ -17,15 +17,6 @@
 
 
 
-namespace PHARE::diagnostic::vtkh5::detail
-{
-
-// some testing shows 32 to be the max value supported, something to do with a value `H5S_MAX_RANK`
-static inline auto const CHUNK_SIZE = core::get_env_as("PHARE_VTK_H5_CHUNK_SIZE", std::size_t{32});
-
-} // namespace PHARE::diagnostic::vtkh5::detail
-
-
 namespace PHARE::diagnostic::vtkh5
 {
 
@@ -55,7 +46,7 @@ class H5TypeWriter : public PHARE::diagnostic::TypeWriter
     // data is duplicated in lower dimensions to fit a 3d view
     //  so 2d data is * 2
     //  and 1d data is * 4
-    constexpr static auto X_TIMES = std::array{4, 2, /* 3d noop */ 1}[dimension - 1];
+    constexpr static auto X_TIMES = std::array{4, 2, 1}[dimension - 1];
 
     auto static flatten_boxes(auto const& boxes)
     {
@@ -126,7 +117,8 @@ struct H5TypeWriter<Writer>::VTKFileWriter
     {
         // set global per file attributes and datasets
         {
-            initDSDefault(base + "/Steps/Values");
+            h5file.create_resizable_1d_data_set<FloatType>(base + "/Steps/Values");
+
             auto steps_group = h5file.file().getGroup(base + "/Steps");
             if (!steps_group.hasAttribute("NSteps"))
                 steps_group.template createAttribute<int>("NSteps", HighFive::DataSpace::From(0))
@@ -199,47 +191,22 @@ struct H5TypeWriter<Writer>::VTKFileWriter
         }
     }
 
-    template<typename T = FloatType>
-    void initDS(auto const& path, auto const& ds) const
-    {
-        h5file.template create_chunked_data_set<T>(path, std::vector<hsize_t>{detail::CHUNK_SIZE},
-                                                   ds);
-    }
 
-    template<typename T = FloatType>
-    void initDSDefault(auto const& path) const
-    {
-        initDS<T>(path, HighFive::DataSpace({0}, {HighFive::DataSpace::UNLIMITED}));
-    }
 
     void initFileLevel(int const level) const
     {
         auto const lvl = std::to_string(level);
 
-        {
-            auto const path = level_base + lvl + "/AMRBox";
-            h5file.template create_chunked_data_set<int>(
-                path, std::vector<hsize_t>{detail::CHUNK_SIZE, boxValsIn3D},
-                HighFive::DataSpace({0, boxValsIn3D},
-                                    {HighFive::DataSpace::UNLIMITED, boxValsIn3D}));
-        }
-
-        auto const chucked_int_datasets
-            = std::array{step_level + lvl + "/PointDataOffset/data",
-                         step_level + lvl + "/AMRBoxOffset", step_level + lvl + "/NumberOfAMRBox"};
-
-        for (auto const& path : chucked_int_datasets)
-        {
-            h5file.template create_chunked_data_set<int>(
-                path, std::vector<hsize_t>{detail::CHUNK_SIZE},
-                HighFive::DataSpace({0}, {HighFive::DataSpace::UNLIMITED}));
-        }
+        h5file.create_resizable_2d_data_set<int, boxValsIn3D>(level_base + lvl + "/AMRBox");
+        h5file.create_resizable_1d_data_set<int>(step_level + lvl + "/PointDataOffset/data");
+        h5file.create_resizable_1d_data_set<int>(step_level + lvl + "/AMRBoxOffset");
+        h5file.create_resizable_1d_data_set<int>(step_level + lvl + "/NumberOfAMRBox");
 
         auto level_group = h5file.file().getGroup(level_base + lvl);
         if (!level_group.hasAttribute("Spacing"))
         {
-            level_group.template createAttribute<std::array<float, dimension>>(
-                "Spacing", level_spacing(level));
+            level_group.createAttribute<std::array<float, dimension>>("Spacing",
+                                                                      level_spacing(level));
 
             level_group.createGroup("CellData");
             level_group.createGroup("FieldData");
@@ -253,10 +220,8 @@ struct H5TypeWriter<Writer>::VTKFileWriter
     template<std::size_t N = 1>
     void initAnyFieldLevel(int const level, auto& boxes)
     {
-        auto const path = level_base + std::to_string(level) + "/PointData/data";
-        h5file.template create_chunked_data_set<FloatType>(
-            path, std::vector<hsize_t>{detail::CHUNK_SIZE, N},
-            HighFive::DataSpace({0, N}, {HighFive::DataSpace::UNLIMITED, N}));
+        auto const lvl = std::to_string(level);
+        h5file.create_resizable_2d_data_set<FloatType, N>(level_base + lvl + "/PointData/data");
         resize<N>(level, boxes);
     }
 

src/hdf5/detail/h5/h5_file.hpp

@@ -3,13 +3,24 @@
 
 #include "core/def.hpp"
 #include "core/def/phare_mpi.hpp" // IWYU pragma: keep
-#include "highfive/H5File.hpp"
-#include "highfive/H5Easy.hpp"
-
 #include "core/utilities/types.hpp"
 #include "core/utilities/mpi_utils.hpp"
 #include "core/utilities/meta/meta_utilities.hpp"
 
+
+#include "highfive/H5File.hpp"
+#include "highfive/H5Easy.hpp"
+
+
+
+namespace PHARE::hdf5::h5::detail
+{
+
+// some testing shows 32 to be the max value supported, something to do with a value `H5S_MAX_RANK`
+static inline auto const CHUNK_SIZE = core::get_env_as("PHARE_H5_CHUNK_SIZE", std::size_t{32});
+
+} // namespace PHARE::hdf5::h5::detail
+
 namespace PHARE::hdf5::h5
 {
 using HiFile = HighFive::File;
@@ -107,14 +118,28 @@ class HighFiveFile
     {
         if (exist(path))
             return h5file_.getDataSet(path);
-
-
         createGroupsToDataSet(path);
         HighFive::DataSetCreateProps props;
         props.add(HighFive::Chunking{chunk});
         return h5file_.createDataSet(path, dataspace, HighFive::create_datatype<Type>(), props);
     }
 
+    template<typename Type, std::size_t cols>
+    auto create_resizable_2d_data_set(auto const& path)
+    {
+        return create_chunked_data_set<Type>(
+            path, std::vector<hsize_t>{detail::CHUNK_SIZE, cols},
+            HighFive::DataSpace({0, cols}, {HighFive::DataSpace::UNLIMITED, cols}));
+    }
+
+    template<typename Type>
+    auto create_resizable_1d_data_set(auto const& path)
+    {
+        return create_chunked_data_set<Type>(
+            path, std::vector<hsize_t>{detail::CHUNK_SIZE},
+            HighFive::DataSpace({0}, {HighFive::DataSpace::UNLIMITED}));
+    }
+
 
     /*
      * Communicate all dataset paths and sizes to all MPI process to allow each to create all