Merge pull request #49 from guj/hdf5

setting up for hdf5

CMakeLists.txt

@@ -137,4 +137,5 @@ message("    MPI:     ${ADIOS_USE_MPI}")
 message("    BZip2:   ${ADIOS_USE_BZip2}")
 message("    ADIOS1:  ${ADIOS_USE_ADIOS1}")
 message("    DataMan: ${ADIOS_USE_DataMan}")
+message("    HDF5: ${ADIOS_USE_PHDF5}")
 message("")

examples/hello/CMakeLists.txt

@@ -14,3 +14,7 @@ if(ADIOS_USE_DataMan)
   add_subdirectory(datamanReader)
   add_subdirectory(datamanWriter)
 endif()
+
+if(ADIOS_USE_PHDF5)
+  add_subdirectory(hdf5Writer)
+endif()

examples/hello/hdf5Writer/CMakeLists.txt

+#------------------------------------------------------------------------------#
+# Distributed under the OSI-approved Apache License, Version 2.0.  See
+# accompanying file Copyright.txt for details.
+#------------------------------------------------------------------------------#
+
+#add_executable(hello_hdf5Writer_nompi helloHDF5Writer_nompi.cpp)
+message("    HDF5:   ${HDF5_INCLUDE_DIRS}")
+include_directories(${HDF5_INCLUDE_DIRS})
+#target_link_libraries(hello_hdf5Writer_nompi adios2_nompi)
+
+if(ADIOS_BUILD_TESTING)
+  #add_test(
+  #  NAME Example::hello::hdf5Writer_nompi
+  #  COMMAND hello_hdf5Writer_nompi
+  #)
+endif()
+
+if(ADIOS_USE_MPI)
+  find_package(MPI COMPONENTS C REQUIRED)
+
+  add_executable(hello_hdf5Writer helloHDF5Writer.cpp)
+  target_link_libraries(hello_hdf5Writer adios2)
+  target_include_directories(hello_hdf5Writer PRIVATE ${MPI_C_INCLUDE_PATH})
+  target_link_libraries(hello_hdf5Writer adios2 ${MPI_C_LIBRARIES})
+
+  if(ADIOS_BUILD_TESTING)
+    add_test(NAME Example::hello::hdf5Writer COMMAND hello_hdf5Writer)
+  endif()
+endif()
+

examples/hello/hdf5Writer/helloHDF5Writer.cpp

+/*
+ * HDF5Writer.cpp
+ *
+ *  Created on: March 20, 2017
+ *      Author: Junmin
+ */
+
+#include <iostream>
+#include <vector>
+
+#include <mpi.h>
+
+#include "ADIOS_CPP.h"
+
+int main(int argc, char *argv[])
+{
+    MPI_Init(&argc, &argv);
+    int rank, size;
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    const bool adiosDebug = true;
+    adios::ADIOS adios(MPI_COMM_WORLD, adios::Verbose::INFO, adiosDebug);
+
+    // Application variable
+    const std::size_t intDim1 = 4;
+    const std::size_t intDim2 = 3;
+    std::vector<int> myInts = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
+
+    std::vector<double> myDoubles = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    const std::size_t Nx = myDoubles.size();
+
+    std::vector<std::complex<float>> myCFloats;
+    const std::size_t ComplexDataSize = 3;
+    myCFloats.reserve(ComplexDataSize);
+    myCFloats.emplace_back(1, 3);
+    myCFloats.emplace_back(2, 2);
+    myCFloats.emplace_back(3, 1);
+
+    std::vector<std::complex<double>> myCDoubles;
+    myCDoubles.reserve(ComplexDataSize);
+    myCDoubles.emplace_back(1.1, -3.3);
+    myCDoubles.emplace_back(2.1, -2.2);
+    myCDoubles.emplace_back(3.1, -1.1);
+
+    std::vector<std::complex<long double>> myCLongDoubles;
+    myCLongDoubles.reserve(ComplexDataSize);
+    myCLongDoubles.emplace_back(1.11, -3.33);
+    myCLongDoubles.emplace_back(2.11, -2.22);
+    myCLongDoubles.emplace_back(3.11, -1.11);
+
+    std::size_t doubleVCount = Nx / size;
+    std::size_t complexCount = ComplexDataSize / size;
+    std::size_t intCountDim1 = intDim1 / size;
+
+    std::size_t doubleVOffset = rank * doubleVCount;
+    std::size_t complexOffset = rank * complexCount;
+    std::size_t intOffsetDim1 = rank * intCountDim1;
+    std::size_t intOffsetDim2 = 0;
+
+    if ((size > 1) && (rank == size - 1))
+    {
+        doubleVCount = Nx - rank * (Nx / size);
+        complexCount = ComplexDataSize - rank * (ComplexDataSize / size);
+        intCountDim1 = intDim1 - rank * (intDim1 / size);
+    }
+
+    try
+    {
+        // Define variable and local size
+        auto &ioMyInts =
+            adios.DefineVariable<int>("myInts", {intCountDim1, intDim2}, {4, 3},
+                                      {intOffsetDim1, intOffsetDim2});
+        auto &ioMyDoubles = adios.DefineVariable<double>(
+            "myDoubles", {doubleVCount}, {Nx}, {doubleVOffset});
+        auto &ioMyCFloats = adios.DefineVariable<std::complex<float>>(
+            "myCFloats", {complexCount}, {3}, {complexOffset});
+        auto &ioMyCDoubles = adios.DefineVariable<std::complex<double>>(
+            "myCDoubles", {complexCount}, {3}, {complexOffset});
+        auto &ioMyCLongDoubles =
+            adios.DefineVariable<std::complex<long double>>(
+                "myCLongDoubles", {complexCount}, {3}, {complexOffset});
+
+        // Define method for engine creation, it is basically straight-forward
+        // parameters
+        adios::Method &HDF5Settings = adios.DeclareMethod("w");
+        HDF5Settings.SetEngine("HDF5Writer");
+        HDF5Settings.SetParameters("chunck=yes", "collectiveIO=yes");
+        // HDF5Settings.AddTransport( "Mdtm", "localIP=128.0.0.0.1",
+        // "remoteIP=128.0.0.0.2", "tolerances=1,2,3" );
+
+        // Create engine smart pointer to HDF5 Engine due to polymorphism,
+        // Open returns a smart pointer to Engine containing the Derived class
+        // HDF5
+        auto HDF5Writer = adios.Open("test.h5", "w", HDF5Settings);
+
+        if (HDF5Writer == nullptr)
+            throw std::ios_base::failure(
+                "ERROR: failed to create HDF5 I/O engine at Open\n");
+
+        HDF5Writer->Write(ioMyDoubles, myDoubles.data() +
+                                           doubleVOffset); // Base class Engine
+                                                           // own the Write<T>
+                                                           // that will call
+                                                           // overloaded Write
+                                                           // from Derived
+        HDF5Writer->Write(ioMyInts,
+                          myInts.data() + (intOffsetDim1 * intDim2 * rank));
+
+        HDF5Writer->Write(ioMyCFloats, myCFloats.data() + complexOffset);
+        HDF5Writer->Write(ioMyCDoubles, myCDoubles.data() + complexOffset);
+        HDF5Writer->Write(ioMyCLongDoubles,
+                          myCLongDoubles.data() + complexOffset);
+        HDF5Writer->Close();
+    }
+    catch (std::invalid_argument &e)
+    {
+        if (rank == 0)
+        {
+            std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
+            std::cout << e.what() << "\n";
+        }
+    }
+    catch (std::ios_base::failure &e)
+    {
+        if (rank == 0)
+        {
+            std::cout << "System exception, STOPPING PROGRAM\n";
+            std::cout << e.what() << "\n";
+        }
+    }
+    catch (std::exception &e)
+    {
+        if (rank == 0)
+        {
+            std::cout << "Exception, STOPPING PROGRAM\n";
+            std::cout << e.what() << "\n";
+        }
+    }
+
+    MPI_Finalize();
+
+    return 0;
+}

include/engine/hdf5/HDF5ReaderP.h

+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0.  See
+ * accompanying file Copyright.txt for details.
+ *
+ * HDF5ReaderP.h
+ *
+ *  Created on: March 20, 2017
+ *      Author: Junmin
+ */
+
+#ifndef HDF5_READER_P_H
+#define HDF5_READER_P_H
+
+#endif

include/engine/hdf5/HDF5WriterP.h

+
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0.  See
+ * accompanying file Copyright.txt for details.
+ *
+ * HDF5WriterP.h
+ *
+ *  Created on: March 20, 2017
+ *      Author: Junmin
+ */
+
+#ifndef HDF5_WRITER_P_H_
+#define HDF5_WRITER_P_H_
+
+#include "core/Engine.h"
+
+// supported capsules
+#include "capsule/heap/STLVector.h"
+
+#include "ADIOS_MPI.h"
+
+#include <hdf5.h>
+
+namespace adios
+{
+
+class HDF5Writer : public Engine
+{
+
+public:
+    /**
+     * Constructor for single BP capsule engine, writes in BP format into a
+     * single
+     * heap capsule
+     * @param name unique name given to the engine
+     * @param accessMode
+     * @param mpiComm
+     * @param method
+     * @param debugMode
+     */
+    HDF5Writer(ADIOS &adios, const std::string name,
+               const std::string accessMode, MPI_Comm mpiComm,
+               const Method &method);
+
+    virtual ~HDF5Writer();
+
+    void Write(Variable<char> &variable, const char *values);
+    void Write(Variable<unsigned char> &variable, const unsigned char *values);
+    void Write(Variable<short> &variable, const short *values);
+    void Write(Variable<unsigned short> &variable,
+               const unsigned short *values);
+    void Write(Variable<int> &variable, const int *values);
+    void Write(Variable<unsigned int> &variable, const unsigned int *values);
+    void Write(Variable<long int> &variable, const long int *values);
+    void Write(Variable<unsigned long int> &variable,
+               const unsigned long int *values);
+    void Write(Variable<long long int> &variable, const long long int *values);
+    void Write(Variable<unsigned long long int> &variable,
+               const unsigned long long int *values);
+    void Write(Variable<float> &variable, const float *values);
+    void Write(Variable<double> &variable, const double *values);
+    void Write(Variable<long double> &variable, const long double *values);
+    void Write(Variable<std::complex<float>> &variable,
+               const std::complex<float> *values);
+    void Write(Variable<std::complex<double>> &variable,
+               const std::complex<double> *values);
+    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,
+               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,
+               const std::complex<float> *values);
+    void Write(const std::string variableName,
+               const std::complex<double> *values);
+    void Write(const std::string variableName,
+               const std::complex<long double> *values);
+
+    void Close(const int transportIndex = -1);
+
+private:
+    capsule::STLVector
+        m_Buffer; ///< heap capsule, contains data and metadata buffers
+
+    void Init();
+    void clean();
+
+    hid_t _plist_id, _file_id, _dset_id;
+    hid_t _memspace, _filespace;
+
+    hid_t DefH5T_COMPLEX_DOUBLE;
+    hid_t DefH5T_COMPLEX_FLOAT;
+    hid_t DefH5T_COMPLEX_LongDOUBLE;
+
+    template <class T>
+    void UseHDFWrite(Variable<T> &variable, const T *values, hid_t h5type);
+};
+
+} // end namespace adios
+
+#endif /* HDF5_WRITER_P_H_ */

source/ADIOS.cpp

@@ -36,6 +36,12 @@
 #include "engine/adios1/ADIOS1Writer.h"
 #endif
 
+#ifdef ADIOS_HAVE_PHDF5 // external dependencies
+#ifdef ADIOS_HAVE_MPI
+#include "engine/hdf5/HDF5ReaderP.h"
+#include "engine/hdf5/HDF5WriterP.h"
+#endif
+#endif
 namespace adios
 {
 
@@ -186,6 +192,17 @@ std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
         // method,
         // iomode, timeout_sec, m_DebugMode, method.m_nThreads );
     }
+    else if (type == "HDF5Writer") // -junmin
+    {
+#if defined(ADIOS_HAVE_PHDF5) && defined(ADIOS_HAVE_MPI)
+        return std::make_shared<HDF5Writer>(*this, name, accessMode, mpiComm,
+                                            method);
+#else
+        throw std::invalid_argument("ERROR: this version didn't compile with "
+                                    "HDF5 library, can't use HDF5\n");
+#endif
+    }
+
     else
     {
         if (m_DebugMode == true)

source/CMakeLists.txt

@@ -25,6 +25,12 @@ foreach(adios2_target IN LISTS adios2_targets)
   
     engine/bp/BPFileReader.cpp
     engine/bp/BPFileWriter.cpp
+
+    utilities/format/bp1/BP1Base.cpp
+    utilities/format/bp1/BP1Aggregator.cpp
+    utilities/format/bp1/BP1Writer.cpp
+    
+    utilities/profiling/iochrono/Timer.cpp
   
     functions/adiosFunctions.cpp
   
@@ -54,6 +60,7 @@ foreach(adios2_target IN LISTS adios2_targets)
     target_compile_definitions(${adios2_target} PRIVATE ADIOS_HAVE_DATAMAN)
     target_link_libraries(${adios2_target} PRIVATE ${CMAKE_DL_LIBS})
   endif()
+
   
   if(ADIOS_USE_BZip2)
     find_package(BZip2 REQUIRED)
@@ -83,4 +90,20 @@ if(ADIOS_USE_MPI)
     target_compile_definitions(adios2 PRIVATE ADIOS_HAVE_ADIOS1)
     target_link_libraries(adios2 PRIVATE adios1::adios)
   endif()
+
+  if(ADIOS_USE_PHDF5)
+    find_package(HDF5 REQUIRED)
+    message("    HDF5 ROOT:   ${HDF5_ROOT}")
+    message("    HDF5 include:   ${HDF5_INCLUDE_DIRS}   is paralle? ${HDF5_IS_PARALLEL}")
+
+    target_include_directories(adios2 PRIVATE ${HDF5_INCLUDE_DIRS})
+
+    target_sources(adios2 PRIVATE
+      engine/hdf5/HDF5ReaderP.cpp
+      engine/hdf5/HDF5WriterP.cpp
+    )
+    target_compile_definitions(adios2 PRIVATE ADIOS_HAVE_PHDF5)
+    target_link_libraries(adios2 PRIVATE ${HDF5_C_LIBRARIES})
+  endif()
+
 endif()

source/engine/hdf5/HDF5ReaderP.cpp

+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0.  See
+ * accompanying file Copyright.txt for details.
+ *
+ * HDF5WriterP.cpp
+ *
+ *  Created on: March 20, 2017
+ *      Author: Junmin
+ */
+
+#include <iostream> //needs to go away, this is just for demo purposes
+
+#include "engine/hdf5/HDF5ReaderP.h"

source/engine/hdf5/HDF5WriterP.cpp

+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0.  See
+ * accompanying file Copyright.txt for details.
+ *
+ * HDF5WriterP.cpp
+ *
+ *  Created on: March 20, 2017
+ *      Author: Junmin
+ */
+
+#include <iostream> //needs to go away, this is just for demo purposes
+
+#include "engine/hdf5/HDF5WriterP.h"
+
+#include "core/Support.h"
+#include "functions/adiosFunctions.h" //CSVToVector
+
+namespace adios
+{
+
+HDF5Writer::HDF5Writer(ADIOS &adios, const std::string name,
+                       const std::string accessMode, MPI_Comm mpiComm,
+                       const Method &method)
+: Engine(adios, "HDF5Writer", name, accessMode, mpiComm,
+         method, /*debugMode, cores,*/
+         " HDF5Writer constructor (or call to ADIOS Open).\n"),
+  m_Buffer(accessMode, m_RankMPI, m_DebugMode)
+{
+    //
+    //  16, 4 vs: 8
+    // std::cout<<sizeof(std::complex<double>)<<",
+    // "<<sizeof(H5T_NATIVE_DOUBLE)<<" vs:
+    // "<<H5Tget_size(H5T_NATIVE_DOUBLE)<<std::endl;
+    //  8, 4 vs: 4
+    // std::cout<<sizeof(std::complex<float>)<<", "<<sizeof(H5T_NATIVE_FLOAT)<<"
+    // vs: "<<H5Tget_size(H5T_NATIVE_FLOAT)<<std::endl;
+    //  32, 4 vs: 16
+    // std::cout<<sizeof(std::complex<long double>)<<",
+    // "<<sizeof(H5T_NATIVE_LDOUBLE)<<" vs:
+    // "<<H5Tget_size(H5T_NATIVE_LDOUBLE)<<std::endl;
+
+    DefH5T_COMPLEX_FLOAT = H5Tcreate(H5T_COMPOUND, sizeof(std::complex<float>));
+    H5Tinsert(DefH5T_COMPLEX_FLOAT, "freal", 0, H5T_NATIVE_FLOAT);
+    H5Tinsert(DefH5T_COMPLEX_FLOAT, "fimg", H5Tget_size(H5T_NATIVE_FLOAT),
+              H5T_NATIVE_FLOAT);
+
+    DefH5T_COMPLEX_DOUBLE =
+        H5Tcreate(H5T_COMPOUND, sizeof(std::complex<double>));
+    H5Tinsert(DefH5T_COMPLEX_DOUBLE, "dreal", 0, H5T_NATIVE_DOUBLE);
+    H5Tinsert(DefH5T_COMPLEX_DOUBLE, "dimg", H5Tget_size(H5T_NATIVE_DOUBLE),
+              H5T_NATIVE_DOUBLE);
+
+    DefH5T_COMPLEX_LongDOUBLE =
+        H5Tcreate(H5T_COMPOUND, sizeof(std::complex<long double>));
+    H5Tinsert(DefH5T_COMPLEX_LongDOUBLE, "ldouble real", 0, H5T_NATIVE_LDOUBLE);
+    H5Tinsert(DefH5T_COMPLEX_LongDOUBLE, "ldouble img",
+              H5Tget_size(H5T_NATIVE_LDOUBLE), H5T_NATIVE_LDOUBLE);
+
+    Init();
+}
+
+HDF5Writer::~HDF5Writer() {}
+
+void HDF5Writer::Init()
+{
+    if (m_AccessMode != "w" && m_AccessMode != "write" && m_AccessMode != "a" &&
+        m_AccessMode != "append")
+    {
+        throw std::invalid_argument(
+            "ERROR: HDF5Writer doesn't support access mode " + m_AccessMode +
+            ", in call to ADIOS Open or HDF5Writer constructor\n");
+    }
+    // std::cout << "method: # of inputs:" << m_Method.m_Parameters.size() <<
+    // std::endl;
+
+    // std::cout << "::Init hdf5 parallel writer. File name:" << m_Name <<
+    // std::endl;
+
+    _plist_id = H5Pcreate(H5P_FILE_ACCESS);
+
+    H5Pset_fapl_mpio(_plist_id, m_MPIComm, MPI_INFO_NULL);
+
+    /*
+     * Create a new file collectively and release property list identifier.
+     */
+    _file_id = H5Fcreate(m_Name.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, _plist_id);
+    H5Pclose(_plist_id);
+}
+
+void HDF5Writer::Write(Variable<char> &variable, const char *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_CHAR);
+}
+
+void HDF5Writer::Write(Variable<unsigned char> &variable,
+                       const unsigned char *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_UCHAR);
+}
+
+void HDF5Writer::Write(Variable<short> &variable, const short *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_SHORT);
+}
+
+void HDF5Writer::Write(Variable<unsigned short> &variable,
+                       const unsigned short *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_USHORT);
+}
+
+void HDF5Writer::Write(Variable<int> &variable, const int *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_INT);
+}
+
+void HDF5Writer::Write(Variable<unsigned int> &variable,
+                       const unsigned int *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_UINT);
+}
+
+void HDF5Writer::Write(Variable<long int> &variable, const long int *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_LONG);
+}
+
+void HDF5Writer::Write(Variable<unsigned long int> &variable,
+                       const unsigned long int *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_ULONG);
+}
+
+void HDF5Writer::Write(Variable<long long int> &variable,
+                       const long long int *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_LLONG);
+}
+
+void HDF5Writer::Write(Variable<unsigned long long int> &variable,
+                       const unsigned long long int *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_ULLONG);
+}
+
+void HDF5Writer::Write(Variable<float> &variable, const float *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_FLOAT);
+}
+
+void HDF5Writer::Write(Variable<double> &variable, const double *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_DOUBLE);
+}
+
+void HDF5Writer::Write(Variable<long double> &variable,
+                       const long double *values)
+{
+    UseHDFWrite(variable, values, H5T_NATIVE_LDOUBLE);
+}
+
+void HDF5Writer::Write(Variable<std::complex<float>> &variable,
+                       const std::complex<float> *values)
+{
+    UseHDFWrite(variable, values, DefH5T_COMPLEX_FLOAT);
+}
+
+void HDF5Writer::Write(Variable<std::complex<double>> &variable,
+                       const std::complex<double> *values)
+{
+    UseHDFWrite(variable, values, DefH5T_COMPLEX_DOUBLE);
+}
+
+void HDF5Writer::Write(Variable<std::complex<long double>> &variable,
+                       const std::complex<long double> *values)
+{
+    UseHDFWrite(variable, values, DefH5T_COMPLEX_LongDOUBLE);
+}
+
+// String version
+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,
+                       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)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<short>(variableName), values,
+                H5T_NATIVE_SHORT);
+}
+
+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)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<int>(variableName), values, H5T_NATIVE_INT);
+}
+
+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)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<long int>(variableName), values,
+                H5T_NATIVE_LONG);
+}
+
+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,
+                       const long long int *values)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<long long int>(variableName), values,
+                H5T_NATIVE_LLONG);
+}
+
+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)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<float>(variableName), values,
+                H5T_NATIVE_FLOAT);
+}
+
+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,
+                       const long double *values)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<long double>(variableName), values,
+                H5T_NATIVE_LDOUBLE);
+}
+
+void HDF5Writer::Write(const std::string variableName,
+                       const std::complex<float> *values)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<std::complex<float>>(variableName), values,
+                DefH5T_COMPLEX_FLOAT);
+}
+
+void HDF5Writer::Write(const std::string variableName,
+                       const std::complex<double> *values)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<std::complex<double>>(variableName), values,
+                DefH5T_COMPLEX_DOUBLE);
+}
+
+void HDF5Writer::Write(const std::string variableName,
+                       const std::complex<long double> *values)
+{
+    UseHDFWrite(m_ADIOS.GetVariable<std::complex<long double>>(variableName),
+                values, DefH5T_COMPLEX_LongDOUBLE);
+}
+
+void HDF5Writer::Close(const int transportIndex)
+{
+    // std::cout << " ===> CLOSING HDF5 <===== " << std::endl;
+    // H5Dclose(_dset_id);
+    // H5Sclose(_filespace);
+    // H5Sclose(_memspace);
+    // H5Pclose(_plist_id);
+    H5Fclose(_file_id);
+}
+
+template <class T>
+void HDF5Writer::UseHDFWrite(Variable<T> &variable, const T *values,
+                             hid_t h5type)
+{
+    // here comes your magic at Writing now variable.m_UserValues has the data
+    // passed by the user
+    // set variable
+    variable.m_AppValues = values;
+    m_WrittenVariables.insert(variable.m_Name);
+
+    int dimSize = variable.m_GlobalDimensions.size();
+    /*
+    std::cout << "writting : " << variable.m_Name
+              << " dim size:" << variable.m_GlobalDimensions.size() <<
+    std::endl;
+
+    for (int i = 0; i < dimSize; i++) {
+      std::cout << " dim: " << i << ", size:" << variable.m_GlobalDimensions[i]
+                << " offset=" << variable.m_Offsets[i]
+                << " count=" << variable.m_LocalDimensions[i] << std::endl;
+    }
+    */
+    std::vector<hsize_t> dimsf, count, offset;
+
+    for (int i = 0; i < dimSize; i++)
+    {
+        dimsf.push_back(variable.m_GlobalDimensions[i]);
+        count.push_back(variable.m_LocalDimensions[i]);
+        offset.push_back(variable.m_Offsets[i]);
+    }
+
+    _filespace = H5Screate_simple(dimSize, dimsf.data(), NULL);
+
+    _dset_id = H5Dcreate(_file_id, variable.m_Name.c_str(), h5type, _filespace,
+                         H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    // H5Sclose(_filespace);
+
+    _memspace = H5Screate_simple(dimSize, count.data(), NULL);
+
+    // Select hyperslab
+    _filespace = H5Dget_space(_dset_id);
+    H5Sselect_hyperslab(_filespace, H5S_SELECT_SET, offset.data(), NULL,
+                        count.data(), NULL);
+
+    //  Create property list for collective dataset write.
+
+    _plist_id = H5Pcreate(H5P_DATASET_XFER);
+    H5Pset_dxpl_mpio(_plist_id, H5FD_MPIO_COLLECTIVE);
+
+    herr_t status;
+
+    status =
+        H5Dwrite(_dset_id, h5type, _memspace, _filespace, _plist_id, values);
+
+    if (status < 0)
+    {
+        // error
+        std::cerr << " Write failed. " << std::endl;
+    }
+
+    // std::cout << " ==> User is responsible for freeing the data " <<
+    // std::endl;
+
+    H5Dclose(_dset_id);
+    H5Sclose(_filespace);
+    H5Sclose(_memspace);
+    H5Pclose(_plist_id);
+}
+
+} // end namespace adios