Merge pull request #115 from guj/hdf5

Hdf5

examples/heatTransfer/write/CMakeLists.txt

@@ -53,6 +53,26 @@ if(ADIOS_USE_MPI)
     )
   endif()
 
+
+  if(ADIOS_USE_HDF5)
+    find_package(HDF5 REQUIRED)
+    find_package(MPI COMPONENTS C REQUIRED)
+
+    add_executable(heatTransfer_write_ph5
+      main.cpp
+      HeatTransfer.cpp
+      Settings.cpp
+      IO_ph5.cpp
+    )
+    target_include_directories(heatTransfer_write_ph5
+      PRIVATE ${MPI_C_INCLUDE_PATH} ${HDF5_C_INCLUDE_DIRS}
+    )
+    target_link_libraries(heatTransfer_write_ph5
+      ${MPI_C_LIBRARIES} ${HDF5_C_LIBRARIES}
+    )
+  endif()
+
+
   if(ADIOS_USE_HDF5)
      find_package(MPI COMPONENTS C REQUIRED)
 

examples/heatTransfer/write/IO_ph5.cpp

+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0.  See
+ * accompanying file Copyright.txt for details.
+ *
+ * IO_ADIOS2.cpp
+ *
+ *  Created on: Feb 2017
+ *      Author: Norbert Podhorszki
+ */
+
+#include "IO.h"
+
+#include <hdf5.h>
+#include <ios>
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+class HDF5NativeWriter
+{
+
+public:
+    HDF5NativeWriter(const std::string &fileName);
+    ~HDF5NativeWriter();
+
+    bool Advance();
+    void Close();
+    void CheckWriteGroup();
+
+    void WriteScalar(const std::string &varName, const void *data,
+                     hid_t h5Type);
+    void WriteSimple(const std::string &varName, int dimSize, const void *data,
+                     hid_t h5Type, const hsize_t *shape, const hsize_t *offset,
+                     const hsize_t *count);
+
+    int m_CurrentTimeStep;
+    unsigned int m_TotalTimeSteps;
+
+private:
+    hid_t m_FilePropertyListId;
+    hid_t m_FileId;
+    hid_t m_GroupId;
+};
+
+HDF5NativeWriter::HDF5NativeWriter(const std::string &fileName)
+: m_CurrentTimeStep(0), m_TotalTimeSteps(0)
+{
+    m_FilePropertyListId = H5Pcreate(H5P_FILE_ACCESS);
+
+    // read a file collectively
+    H5Pset_fapl_mpio(m_FilePropertyListId, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+    m_FileId = H5Fcreate(fileName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT,
+                         m_FilePropertyListId);
+
+    if (m_FileId < 0)
+    {
+        throw std::runtime_error("Unable to open " + fileName + " for reading");
+    }
+
+    std::string ts0 = "/TimeStep0";
+
+    m_GroupId = H5Gcreate2(m_FileId, ts0.c_str(), H5P_DEFAULT, H5P_DEFAULT,
+                           H5P_DEFAULT);
+    if (m_GroupId < 0)
+    {
+        throw std::runtime_error("HDF5: Unable to create group " + ts0);
+    }
+}
+
+HDF5NativeWriter::~HDF5NativeWriter() { Close(); }
+
+void HDF5NativeWriter::Close()
+{
+    if (m_FileId < 0)
+        return;
+
+    hid_t s = H5Screate(H5S_SCALAR);
+    hid_t attr = H5Acreate(m_FileId, "NumTimeSteps", H5T_NATIVE_UINT, s,
+                           H5P_DEFAULT, H5P_DEFAULT);
+    uint totalTimeSteps = m_CurrentTimeStep + 1;
+
+    if (m_GroupId < 0)
+    {
+        totalTimeSteps = m_CurrentTimeStep;
+    }
+    H5Awrite(attr, H5T_NATIVE_UINT, &totalTimeSteps);
+    H5Sclose(s);
+    H5Aclose(attr);
+
+    if (m_GroupId >= 0)
+    {
+        H5Gclose(m_GroupId);
+        m_GroupId = -1;
+    }
+
+    H5Fclose(m_FileId);
+    m_FileId = -1;
+    H5Pclose(m_FilePropertyListId);
+}
+
+bool HDF5NativeWriter::Advance()
+{
+    if (m_GroupId >= 0)
+    {
+        H5Gclose(m_GroupId);
+        m_GroupId = -1;
+    }
+
+    ++m_CurrentTimeStep;
+
+    return true;
+}
+
+void HDF5NativeWriter::CheckWriteGroup()
+{
+    if (m_GroupId >= 0)
+    {
+        return;
+    }
+
+    std::string timeStepName = "/TimeStep" + std::to_string(m_CurrentTimeStep);
+    m_GroupId = H5Gcreate2(m_FileId, timeStepName.c_str(), H5P_DEFAULT,
+                           H5P_DEFAULT, H5P_DEFAULT);
+    if (m_GroupId < 0)
+    {
+        throw std::runtime_error("HDF5: Unable to create group " +
+                                 timeStepName);
+    }
+}
+
+void HDF5NativeWriter::WriteScalar(const std::string &varName, const void *data,
+                                   hid_t h5Type)
+{
+    CheckWriteGroup();
+    // scalar
+    hid_t filespaceID = H5Screate(H5S_SCALAR);
+    hid_t dsetID = H5Dcreate(m_GroupId, varName.c_str(), h5Type, filespaceID,
+                             H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    herr_t status =
+        H5Dwrite(dsetID, h5Type, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
+
+    H5Sclose(filespaceID);
+    H5Dclose(dsetID);
+}
+
+void HDF5NativeWriter::WriteSimple(const std::string &varName, int dimSize,
+                                   const void *data, hid_t h5Type,
+                                   const hsize_t *shape, const hsize_t *offset,
+                                   const hsize_t *count)
+{
+    CheckWriteGroup();
+    hid_t fileSpace = H5Screate_simple(dimSize, shape, NULL);
+
+    hid_t dsetID = H5Dcreate(m_GroupId, varName.c_str(), h5Type, fileSpace,
+                             H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+
+    hid_t memSpace = H5Screate_simple(dimSize, count, NULL);
+
+    // Select hyperslab
+    fileSpace = H5Dget_space(dsetID);
+    H5Sselect_hyperslab(fileSpace, H5S_SELECT_SET, offset, NULL, count, NULL);
+
+    //  Create property list for collective dataset write.
+
+    hid_t plistID = H5Pcreate(H5P_DATASET_XFER);
+    H5Pset_dxpl_mpio(plistID, H5FD_MPIO_COLLECTIVE);
+
+    herr_t status;
+
+    status = H5Dwrite(dsetID, h5Type, memSpace, fileSpace, plistID, data);
+
+    if (status < 0)
+    {
+        // error
+        std::cerr << " Write failed. " << std::endl;
+    }
+
+    H5Dclose(dsetID);
+    H5Sclose(fileSpace);
+    H5Sclose(memSpace);
+    H5Pclose(plistID);
+}
+
+//
+//
+std::shared_ptr<HDF5NativeWriter> h5writer;
+// HDF5NativeWriter* h5writer;
+
+IO::IO(const Settings &s, MPI_Comm comm)
+{
+    m_outputfilename = s.outputfile + ".h5";
+
+    if (s.outputfile[0] == '0')
+    {
+        std::cout << " no writer. " << std::endl;
+        h5writer = nullptr;
+        return;
+    }
+    h5writer = std::make_shared<HDF5NativeWriter>(m_outputfilename);
+
+    if (h5writer == nullptr)
+        throw std::ios_base::failure("ERROR: failed to open ADIOS h5writer\n");
+}
+
+IO::~IO()
+{
+    if (h5writer != nullptr)
+    {
+        h5writer->Close();
+    }
+    // delete h5writer;
+}
+
+void IO::write(int step, const HeatTransfer &ht, const Settings &s,
+               MPI_Comm comm)
+{
+    if (h5writer == nullptr)
+    {
+        return;
+    }
+    std::vector<hsize_t> dims = {s.gndx, s.gndy};
+    std::vector<hsize_t> offset = {s.offsx, s.offsy};
+    std::vector<hsize_t> count = {s.ndx, s.ndy};
+
+    h5writer->WriteSimple("T", 2, ht.data_noghost().data(), H5T_NATIVE_DOUBLE,
+                          dims.data(), offset.data(), count.data());
+    h5writer->WriteScalar("gndy", &(s.gndy), H5T_NATIVE_UINT);
+    h5writer->WriteScalar("gndx", &(s.gndx), H5T_NATIVE_UINT);
+
+    h5writer->Advance();
+}

examples/heatTransfer/write/IO_ph5_adios2.cpp

@@ -106,8 +106,8 @@ void IO::write(int step, const HeatTransfer &ht, const Settings &s,
 
     h5writer->Write<double>(*varT, ht.data_noghost().data());
     // h5writer->Write(*varT, ht.data_noghost().data());
-    h5writer->Write<unsigned int>(*varGndx, s.gndx);
-    h5writer->Write<unsigned int>("gndy", s.gndy);
+    h5writer->Write<unsigned int>(*varGndx, &(s.gndx));
+    h5writer->Write("gndy", &(s.gndy));
 
     h5writer->Advance();
 

source/adios2/engine/hdf5/HDF5WriterP.cpp

@@ -134,105 +134,105 @@ void HDF5Writer::Write(Variable<std::complex<long double>> &variable,
 }
 
 // String version
-void HDF5Writer::Write(const std::string variableName, const char *values)
+void HDF5Writer::Write(const std::string &variableName, const char *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<char>(variableName), values,
                 H5T_NATIVE_CHAR);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const unsigned char *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<unsigned char>(variableName), values,
                 H5T_NATIVE_UCHAR);
 }
 
-void HDF5Writer::Write(const std::string variableName, const short *values)
+void HDF5Writer::Write(const std::string &variableName, const short *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<short>(variableName), values,
                 H5T_NATIVE_SHORT);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const unsigned short *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<unsigned short>(variableName), values,
                 H5T_NATIVE_USHORT);
 }
 
-void HDF5Writer::Write(const std::string variableName, const int *values)
+void HDF5Writer::Write(const std::string &variableName, const int *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<int>(variableName), values, H5T_NATIVE_INT);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const unsigned int *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<unsigned int>(variableName), values,
                 H5T_NATIVE_UINT);
 }
 
-void HDF5Writer::Write(const std::string variableName, const long int *values)
+void HDF5Writer::Write(const std::string &variableName, const long int *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<long int>(variableName), values,
                 H5T_NATIVE_LONG);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const unsigned long int *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<unsigned long int>(variableName), values,
                 H5T_NATIVE_ULONG);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const long long int *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<long long int>(variableName), values,
                 H5T_NATIVE_LLONG);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const unsigned long long int *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<unsigned long long int>(variableName),
                 values, H5T_NATIVE_ULLONG);
 }
 
-void HDF5Writer::Write(const std::string variableName, const float *values)
+void HDF5Writer::Write(const std::string &variableName, const float *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<float>(variableName), values,
                 H5T_NATIVE_FLOAT);
 }
 
-void HDF5Writer::Write(const std::string variableName, const double *values)
+void HDF5Writer::Write(const std::string &variableName, const double *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<double>(variableName), values,
                 H5T_NATIVE_DOUBLE);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const long double *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<long double>(variableName), values,
                 H5T_NATIVE_LDOUBLE);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const std::complex<float> *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<std::complex<float>>(variableName), values,
                 m_H5File.m_DefH5TypeComplexFloat);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const std::complex<double> *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<std::complex<double>>(variableName), values,
                 m_H5File.m_DefH5TypeComplexDouble);
 }
 
-void HDF5Writer::Write(const std::string variableName,
+void HDF5Writer::Write(const std::string &variableName,
                        const std::complex<long double> *values)
 {
     UseHDFWrite(m_ADIOS.GetVariable<std::complex<long double>>(variableName),

source/adios2/engine/hdf5/HDF5WriterP.h

@@ -64,25 +64,26 @@ public:
     void Write(Variable<std::complex<long double>> &variable,
                const std::complex<long double> *values);
 
-    void Write(const std::string variableName, const char *values);
-    void Write(const std::string variableName, const unsigned char *values);
-    void Write(const std::string variableName, const short *values);
-    void Write(const std::string variableName, const unsigned short *values);
-    void Write(const std::string variableName, const int *values);
-    void Write(const std::string variableName, const unsigned int *values);
-    void Write(const std::string variableName, const long int *values);
-    void Write(const std::string variableName, const unsigned long int *values);
-    void Write(const std::string variableName, const long long int *values);
-    void Write(const std::string variableName,
+    void Write(const std::string &variableName, const char *values);
+    void Write(const std::string &variableName, const unsigned char *values);
+    void Write(const std::string &variableName, const short *values);
+    void Write(const std::string &variableName, const unsigned short *values);
+    void Write(const std::string &variableName, const int *values);
+    void Write(const std::string &variableName, const unsigned int *values);
+    void Write(const std::string &variableName, const long int *values);
+    void Write(const std::string &variableName,
+               const unsigned long int *values);
+    void Write(const std::string &variableName, const long long int *values);
+    void Write(const std::string &variableName,
                const unsigned long long int *values);
-    void Write(const std::string variableName, const float *values);
-    void Write(const std::string variableName, const double *values);
-    void Write(const std::string variableName, const long double *values);
-    void Write(const std::string variableName,
+    void Write(const std::string &variableName, const float *values);
+    void Write(const std::string &variableName, const double *values);
+    void Write(const std::string &variableName, const long double *values);
+    void Write(const std::string &variableName,
                const std::complex<float> *values);
-    void Write(const std::string variableName,
+    void Write(const std::string &variableName,
                const std::complex<double> *values);
-    void Write(const std::string variableName,
+    void Write(const std::string &variableName,
                const std::complex<long double> *values);
 
     void Advance(float timeoutSec = 0.0);