setting up for hdf5

cmake/FindPHDF5.cmake

+#------------------------------------------------------------------------------#
+# Distributed under the OSI-approved Apache License, Version 2.0.  See
+# accompanying file Copyright.txt for details.
+#------------------------------------------------------------------------------#
+#
+# FindPHDF5
+# ---------
+#
+
+
+if(NOT PHDF5_FOUND)
+  if((NOT HDF5_DIR) AND (NOT (ENV{HDF5_DIR} STREQUAL "")))
+    set(HDF5_DIR "$ENV{HDF5_DIR}")
+  endif()
+
+  # Search for the core libraries
+  if(HDF5_DIR)
+    # If a root directory is specified, then don't look anywhere else 
+    find_path(PHDF5_INCLUDE_DIR hdf5.h
+      HINTS ${HDF5_DIR}/include
+      NO_DEFAULT_PATHS
+    )
+    set(_PHDF5_LIBRARY_HINT HINTS ${HDF5_DIR}/lib NO_DEFAULT_PATHS)
+  else()
+    # Otherwise use the include dir as a basis to search for the lib
+    find_path(PHDF5_INCLUDE_DIR hdf5.h)
+    if(PHDF5_INCLUDE_DIR)
+      get_filename_component(_PHDF5_PREFIX "${PHDF5_INCLUDE_DIR}" PATH)
+      set(_PHDF5_LIBRARY_HINT HINTS ${_PHDF5_PREFIX}/lib)
+      unset(_PHDF5_PREFIX)
+    endif()
+  endif()
+  find_library(PHDF5_LIBRARY hdf5 ${_PHDF5_LIBRARY_HINT})
+  unset(_PHDF5_LIBRARY_HINT)
+
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(PHDF5  DEFAULT_MSG  PHDF5_LIBRARY PHDF5_INCLUDE_DIR)
+
+  find_package_handle_standard_args(PHDF5
+    FOUND_VAR PHDF5_FOUND
+    REQUIRED_VARS
+      PHDF5_INCLUDE_DIR
+      PHDF5_LIBRARY
+  )
+
+  MESSAGE(STATUS "PHDF5_FOUND: " ${PHDF5_FOUND} "HDF5_DIR: " ${HDF5_DIR} "TARGET=" ${TARGET} )
+  if(PHDF5_FOUND)
+    set(PHDF5_INCLUDE_DIRS ${PHDF5_INCLUDE_DIR})
+    set(PHDF5_LIBRARIES ${PHDF5_LIBRARY})
+    if(PHDF5_FOUND AND NOT TARGET PHDF5::PHDF5)
+      add_library(PHDF5::PHDF5 UNKNOWN IMPORTED)
+      set_target_properties(PHDF5::PHDF5 PROPERTIES
+        IMPORTED_LOCATION "${PHDF5_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${PHDF5_INCLUDE_DIR}"
+      )
+    endif()
+  endif()
+endif()

include/engine/hdf5/HDF5ReaderP.h

+#ifndef HDF5_READER_P_H
+#define HDF5_READER_P_H
+
+#endif

include/engine/hdf5/HDF5WriterP.h

+/*
+ * HDF5WriterP.h
+ *
+ *  Created on: March 20, 2017
+ *      Author: Junmin
+ */
+
+#ifndef HDF5_WRITER_P_H_
+#define HDF5_WRITER_P_H_
+
+#include <iostream> //std::cout must be removed, only used for hello example
+#include <unistd.h> //sleep must be removed
+
+#include "core/Engine.h"
+#include "format/BP1Writer.h"
+
+// supported capsules
+#include "capsule/heap/STLVector.h"
+
+#include "ADIOS_MPI.h"
+
+#include "hdf5.h"
+
+namespace adios {
+
+typedef struct {
+  double _re; /*real part*/
+  double _im; /*imaginary part*/
+} ADIOS2_Complex_Double;
+
+typedef struct {
+  float _re; // real
+  float _im; // imaginary part
+} ADIOS2_Complex_Float;
+
+// using ADIOS2_Complex_Float = std::complex<float>;
+
+typedef struct {
+  long double _re; /*real part*/
+  long double _im; /*imaginary part*/
+} ADIOS2_Complex_LongDouble;
+
+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,
+             const bool debugMode = false, const unsigned int cores = 1);
+
+  ~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);
+  /*
+  {
+      std::cout<<" ===> CLOSING HDF5 <===== "<<std::endl;
+      //H5Dclose(_dset_id);
+      //H5Sclose(_filespace);
+      //H5Sclose(_memspace);
+      //H5Pclose(_plist_id);
+      H5Fclose(_file_id);
+  }
+  */
+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;
+
+  hid_t DefH5T_filetype_COMPLEX_DOUBLE;
+  hid_t DefH5T_filetype_COMPLEX_FLOAT;
+  hid_t DefH5T_filetype_COMPLEX_LongDOUBLE;
+
+  template <class T>
+  void UseHDFWrite(Variable<T> &variable, const T *values, hid_t h5type);
+
+  /*
+  template<class T>
+    void 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 );
+
+      std::cout<<"writting : "<<variable.m_Name<<" dim
+  size:"<<variable.m_GlobalDimensions.size()<<std::endl;
+
+      int dimSize = variable.m_GlobalDimensions.size();
+      //hsize_t     dimsf[dimSize], count[dimSize], offset[dimSize];
+      std::vector<hsize_t>  dimsf, count, offset;
+
+      for(int i=0; i<dimSize; i++) {
+        dimsf.push_back(variable.m_GlobalDimensions[i]);
+        count.push_back(dimsf[i]);
+        offset.push_back(0);
+      }
+      count[0] = dimsf[0]/m_SizeMPI;
+      offset[0]= m_RankMPI*count[0];
+
+      _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;
+      if (m_SizeMPI == 1) {
+        status = H5Dwrite(_dset_id, h5type, _memspace, _filespace, _plist_id,
+  values);
+      } else {
+        std::vector<T> val;
+        for (int i=0; i<100; i++) {
+          //hsize_t c = count[i];
+          //hsize_t o = offset[i];
+          val.push_back(0);
+        }
+        status = H5Dwrite(_dset_id, h5type, _memspace, _filespace, _plist_id,
+  val.data());
+      }
+
+      if (status < 0) {
+        // error
+        std::cerr<<" Write failed. "<<std::endl;
+      }
+
+      std::cout <<" ==> User is responsible for freeing the data "<<std::endl;
+      //free(values);
+
+
+      //Close/release resources.
+
+      //H5Dclose(_dset_id);
+      //H5Sclose(_filespace);
+      //H5Sclose(_memspace);
+      //H5Pclose(_plist_id);
+      //H5Fclose(_file_id);
+
+      H5Dclose(_dset_id);
+      H5Sclose(_filespace);
+      H5Sclose(_memspace);
+      H5Pclose(_plist_id);
+
+  }
+  */
+};
+
+} // end namespace adios
+
+#endif /* HDF5_WRITER_P_H_ */

source/engine/hdf5/HDF5ReaderP.cpp

+/*
+ * HDF5ReaderP.cpp
+ *
+ *  Created on: Mar 23, 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

+/*
+ * HDF5WriterP.cpp
+ *
+ *  Created on: Mar 23, 2017
+ *      Author: junmin
+ */
+
+#include <iostream> //needs to go away, this is just for demo purposes
+
+#ifdef ADIOS_HAVE_MPI
+#include "engine/hdf5/HDF5WriterP.h"
+
+#include "core/Support.h"
+#include "functions/adiosFunctions.h" //CSVToVector
+
+// supported transports
+//#include "transport/file/FD.h"      // uses POSIX
+//#include "transport/file/FP.h"      // uses C FILE*
+//#include "transport/file/FStream.h" // uses C++ fstream
+
+namespace adios {
+
+HDF5Writer::HDF5Writer(ADIOS &adios, const std::string name,
+                       const std::string accessMode, MPI_Comm mpiComm,
+                       const Method &method, const bool debugMode,
+                       const unsigned int cores)
+    : Engine(adios, "HDF5Writer", name, accessMode, mpiComm, method, debugMode,
+             cores, " HDF5Writer constructor (or call to ADIOS Open).\n"),
+      m_Buffer(accessMode, m_RankMPI, m_DebugMode) {
+  DefH5T_COMPLEX_DOUBLE =
+      H5Tcreate(H5T_COMPOUND, sizeof(ADIOS2_Complex_Double));
+  DefH5T_COMPLEX_FLOAT = H5Tcreate(H5T_COMPOUND, sizeof(ADIOS2_Complex_Float));
+  DefH5T_COMPLEX_LongDOUBLE =
+      H5Tcreate(H5T_COMPOUND, sizeof(ADIOS2_Complex_LongDouble));
+
+  // compound data type for memory
+  H5Tinsert(DefH5T_COMPLEX_DOUBLE, "double real",
+            HOFFSET(ADIOS2_Complex_Double, _re), H5T_NATIVE_DOUBLE);
+  H5Tinsert(DefH5T_COMPLEX_DOUBLE, "double img",
+            HOFFSET(ADIOS2_Complex_Double, _im), H5T_NATIVE_DOUBLE);
+  H5Tinsert(DefH5T_COMPLEX_FLOAT, "float real",
+            HOFFSET(ADIOS2_Complex_Float, _re), H5T_NATIVE_FLOAT);
+  H5Tinsert(DefH5T_COMPLEX_FLOAT, "float img",
+            HOFFSET(ADIOS2_Complex_Float, _im), H5T_NATIVE_FLOAT);
+  H5Tinsert(DefH5T_COMPLEX_LongDOUBLE, "ldouble real",
+            HOFFSET(ADIOS2_Complex_LongDouble, _re), H5T_NATIVE_LDOUBLE);
+  H5Tinsert(DefH5T_COMPLEX_LongDOUBLE, "ldouble img",
+            HOFFSET(ADIOS2_Complex_LongDouble, _im), H5T_NATIVE_LDOUBLE);
+
+  // data type for file
+  int ldsize = H5Tget_size(H5T_NATIVE_DOUBLE);
+  DefH5T_filetype_COMPLEX_DOUBLE = H5Tcreate(H5T_COMPOUND, ldsize + ldsize);
+  H5Tinsert(DefH5T_filetype_COMPLEX_DOUBLE, "double real", 0, H5T_IEEE_F64BE);
+  H5Tinsert(DefH5T_filetype_COMPLEX_DOUBLE, "double img", ldsize,
+            H5T_IEEE_F64BE);
+
+  ldsize = H5Tget_size(H5T_NATIVE_FLOAT);
+  DefH5T_filetype_COMPLEX_FLOAT = H5Tcreate(H5T_COMPOUND, ldsize + ldsize);
+  H5Tinsert(DefH5T_filetype_COMPLEX_FLOAT, "float real", 0, H5T_IEEE_F32BE);
+  H5Tinsert(DefH5T_filetype_COMPLEX_FLOAT, "float img", ldsize, H5T_IEEE_F32BE);
+
+  ldsize = H5Tget_size(
+      H5T_NATIVE_LDOUBLE); // note that sizeof(H5T_NATIVE_LDOUBLE) returned 4!!
+  DefH5T_filetype_COMPLEX_LongDOUBLE = H5Tcreate(H5T_COMPOUND, ldsize + ldsize);
+  H5Tinsert(DefH5T_filetype_COMPLEX_LongDOUBLE, "ldouble real", 0,
+            H5T_NATIVE_LDOUBLE);
+  H5Tinsert(DefH5T_filetype_COMPLEX_LongDOUBLE, "ldouble img", ldsize,
+            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);
+
+#ifdef HAVE_MPI
+  H5Pset_fapl_mpio(_plist_id, m_MPIComm, MPI_INFO_NULL);
+#endif
+
+  /*
+   * 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_filetype_COMPLEX_FLOAT);
+}
+
+void HDF5Writer::Write(Variable<std::complex<double>> &variable,
+                       const std::complex<double> *values) {
+  UseHDFWrite(variable, values, DefH5T_filetype_COMPLEX_DOUBLE);
+}
+
+void HDF5Writer::Write(Variable<std::complex<long double>> &variable,
+                       const std::complex<long double> *values) {
+  UseHDFWrite(variable, values, DefH5T_filetype_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);
+
+  std::cout << "writting : " << variable.m_Name
+            << " dim size:" << variable.m_GlobalDimensions.size() << std::endl;
+
+  int dimSize = variable.m_GlobalDimensions.size();
+  for (int i = 0; i < dimSize; i++) {
+    std::cout << " dim: " << i << ", size:" << variable.m_GlobalDimensions[i]
+              << " offset=" << variable.m_GlobalOffsets[i]
+              << " count=" << variable.m_Dimensions[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_Dimensions[i]);
+    offset.push_back(variable.m_GlobalOffsets[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;
+
+  if (h5type == DefH5T_filetype_COMPLEX_FLOAT) {
+    /*
+    ADIOS2_Complex_Float v[3];
+    v[0]._re = 1.1, v[0]._im = 1.2;
+    v[1]._re = 2.1, v[1]._im = 2.2;
+    v[2]._re = 3.1, v[2]._im = 3.2;
+    // status = H5Dwrite(_dset_id, DefH5T_COMPLEX_FLOAT, _memspace, _filespace,
+    // _plist_id, values);
+    status = H5Dwrite(_dset_id, DefH5T_COMPLEX_FLOAT, _memspace, _filespace,
+                      _plist_id, v);
+    */
+  } else if (h5type == DefH5T_filetype_COMPLEX_DOUBLE) {
+    /*
+    ADIOS2_Complex_Double v[3];
+    v[0]._re = 1.1, v[0]._im = 1.2;
+    v[1]._re = 2.1, v[1]._im = 2.2;
+    v[2]._re = 3.1, v[2]._im = 3.2;
+    status = H5Dwrite(_dset_id, DefH5T_COMPLEX_DOUBLE, _memspace, _filespace,
+                      _plist_id, v);
+    */
+  } else if (h5type == DefH5T_filetype_COMPLEX_LongDOUBLE) {
+    /*
+    ADIOS2_Complex_LongDouble v[3];
+    v[0]._re = 1.1, v[0]._im = 1.2;
+    v[1]._re = 2.1, v[1]._im = 2.2;
+    v[2]._re = 3.1, v[2]._im = 3.2;
+    status = H5Dwrite(_dset_id, DefH5T_COMPLEX_LongDOUBLE, _memspace,
+                      _filespace, _plist_id, v);
+    */
+  } else {
+    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;
+  // free(values);
+
+  // Close/release resources.
+
+  // H5Dclose(_dset_id);
+  // H5Sclose(_filespace);
+  // H5Sclose(_memspace);
+  // H5Pclose(_plist_id);
+  // H5Fclose(_file_id);
+
+  H5Dclose(_dset_id);
+  H5Sclose(_filespace);
+  H5Sclose(_memspace);
+  H5Pclose(_plist_id);
+}
+
+} // end namespace adios
+
+#endif //ADIOS_HAVE_MPI