hdf5.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2018 - 2019 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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_hdf5_h
#define dealii_hdf5_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_HDF5
 
#  include <deal.II/lac/full_matrix.h>
 
#  include <hdf5.h>
 
#  include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// It is necessary to turn clang-format off in order to maintain the Doxygen
// links because they are longer than 80 characters
// clang-format off
// clang-format on
namespace HDF5
{
  class HDF5Object
  {
  protected:
    HDF5Object(const std::string &name, const bool mpi);
 
  public:
    template <typename T>
    T
    get_attribute(const std::string &attr_name) const;
 
    template <typename T>
    void
    set_attribute(const std::string &attr_name, const T value);
 
    std::string
    get_name() const;
 
  protected:
    const std::string name;
 
    std::shared_ptr<hid_t> hdf5_reference;
 
    const bool mpi;
  };
 
  class DataSet : public HDF5Object
  {
    friend class Group;
 
  protected:
    DataSet(const std::string &name, const hid_t &parent_group_id, bool mpi);
 
    DataSet(const std::string &           name,
            const hid_t &                 parent_group_id,
            const std::vector<hsize_t> &  dimensions,
            const std::shared_ptr<hid_t> &t_type,
            const bool                    mpi);
 
  public:
    template <typename Container>
    Container
    read();
 
    template <typename Container>
    Container
    read_selection(const std::vector<hsize_t> &coordinates);
 
    // clang-format off
    // clang-format on
    template <typename Container>
    Container
    read_hyperslab(const std::vector<hsize_t> &offset,
                   const std::vector<hsize_t> &count);
 
    template <typename Container>
    Container
    read_hyperslab(const std::vector<hsize_t> &data_dimensions,
                   const std::vector<hsize_t> &offset,
                   const std::vector<hsize_t> &stride,
                   const std::vector<hsize_t> &count,
                   const std::vector<hsize_t> &block);
 
    template <typename number>
    void
    read_none();
 
    template <typename Container>
    void
    write(const Container &data);
 
    template <typename Container>
    void
    write_selection(const Container &           data,
                    const std::vector<hsize_t> &coordinates);
 
    // clang-format off
    // clang-format on
    template <typename Container>
    void
    write_hyperslab(const Container &           data,
                    const std::vector<hsize_t> &offset,
                    const std::vector<hsize_t> &count);
 
    template <typename Container>
    void
    write_hyperslab(const Container &           data,
                    const std::vector<hsize_t> &data_dimensions,
                    const std::vector<hsize_t> &offset,
                    const std::vector<hsize_t> &stride,
                    const std::vector<hsize_t> &count,
                    const std::vector<hsize_t> &block);
 
    template <typename number>
    void
    write_none();
 
    bool
    get_query_io_mode() const;
 
    void
    set_query_io_mode(const bool new_query_io_mode);
 
    std::string
    get_io_mode();
 
    H5D_mpio_actual_io_mode_t
    get_io_mode_as_hdf5_type();
 
    std::string
    get_local_no_collective_cause();
 
    uint32_t
    get_local_no_collective_cause_as_hdf5_type();
 
    std::string
    get_global_no_collective_cause();
 
    uint32_t
    get_global_no_collective_cause_as_hdf5_type();
 
    std::vector<hsize_t>
    get_dimensions() const;
 
    unsigned int
    get_size() const;
 
    unsigned int
    get_rank() const;
 
  private:
    unsigned int rank;
 
    std::vector<hsize_t> dimensions;
 
    std::shared_ptr<hid_t> dataspace;
 
    unsigned int size;
 
    bool query_io_mode;
 
    H5D_mpio_actual_io_mode_t io_mode;
 
    uint32_t local_no_collective_cause;
 
    uint32_t global_no_collective_cause;
  };
 
  class Group : public HDF5Object
  {
  protected:
    enum class GroupAccessMode
    {
      open,
      create
    };
    Group(const std::string &   name,
          const Group &         parent_group,
          const bool            mpi,
          const GroupAccessMode mode);
 
    Group(const std::string &name, const bool mpi);
 
  public:
    Group
    open_group(const std::string &name) const;
 
    Group
    create_group(const std::string &name) const;
 
    DataSet
    open_dataset(const std::string &name) const;
 
    template <typename number>
    DataSet
    create_dataset(const std::string &         name,
                   const std::vector<hsize_t> &dimensions) const;
 
    template <typename Container>
    void
    write_dataset(const std::string &name, const Container &data) const;
  };
 
  class File : public Group
  {
  public:
    enum class FileAccessMode
    {
      open,
      create
    };
 
    File(const std::string &name, const FileAccessMode mode);
 
    File(const std::string &  name,
         const FileAccessMode mode,
         const MPI_Comm       mpi_communicator);
 
  private:
    File(const std::string &  name,
         const FileAccessMode mode,
         const bool           mpi,
         const MPI_Comm       mpi_communicator);
  };
} // namespace HDF5
 
DEAL_II_NAMESPACE_CLOSE
 
 
#endif // DEAL_II_WITH_HDF5
 
#endif // dealii_hdf5_h