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