hdf5_file.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                  license: HDF5Application/license.txt
//
//  Main author:    Michael Andre, https://github.com/msandre
//                  Suneth Warnakulasuriya
//
 
#pragma once
 
// System includes
#include <vector>
#include <string>
 
// External includes
 
// Project includes
#include "containers/array_1d.h"
#include "includes/data_communicator.h"
#include "includes/define.h"
#include "includes/kratos_parameters.h"
 
// Application includes
#include "hdf5_application_define.h"
 
namespace Kratos
{
 
namespace HDF5
{
 
 
struct WriteInfo
{
    std::size_t StartIndex = -1;
    std::size_t BlockSize = -1;
    std::size_t TotalSize = -1;
};
 
 
class KRATOS_API(HDF5_APPLICATION) File
{
private:
 
    enum class DataTransferMode
    {
        Independent,
        Collective
    };
 
 
public:
 
    template <class T>
    using Vector = HDF5::Vector<T>;
 
    template <class T>
    using Matrix = HDF5::Matrix<T>;
 
    KRATOS_CLASS_POINTER_DEFINITION(File);
 
 
    explicit File(
        const DataCommunicator& rDataCommunicator,
        Parameters Settings);
 
    File(const File& rOther) = delete;
 
    File(File&& rOther);
 
    virtual ~File();
 
    File& operator=(const File& rOther) = delete;
 
    File& operator=(File&& rOther);
 
 
    bool HasPath(const std::string& rPath) const;
 
    bool IsGroup(const std::string& rPath) const;
 
    bool IsDataSet(const std::string& rPath) const;
 
    bool HasAttribute(
        const std::string& rObjectPath,
        const std::string& rName) const;
 
    template<class TDataType>
    bool HasAttributeType(
        const std::string& rObjectPath,
        const std::string& rName) const;
 
    std::vector<hsize_t> GetAttributeDimensions(
        const std::string& rObjectPath,
        const std::string& rName) const;
 
    void DeleteAttribute(
        const std::string& rObjectPath,
        const std::string& rName);
 
    std::vector<std::string> GetAttributeNames(const std::string& rObjectPath) const;
 
    void CreateGroup(const std::string& rPath);
 
    std::vector<std::string> GetLinkNames(const std::string& rGroupPath) const;
 
    std::vector<std::string> GetGroupNames(const std::string& rGroupPath) const;
 
    std::vector<std::string> GetDataSetNames(const std::string& rGroupPath) const;
 
    void AddPath(const std::string& rPath);
 
    template<class TDataType>
    void WriteAttribute(
        const std::string& rObjectPath,
        const std::string& rName,
        const TDataType& rValue);
 
    void WriteAttribute(
        const std::string& rObjectPath,
        const Parameters Attributes);
 
    template<class TDataType>
    void WriteDataSet(
        const std::string& rPath,
        const TDataType& rData,
        WriteInfo& rInfo);
 
    template<class TDataType>
    void WriteDataSetIndependent(
        const std::string& rPath,
        const TDataType& rData,
        WriteInfo& rInfo);
 
    std::vector<unsigned> GetDataDimensions(const std::string& rPath) const;
 
    bool HasIntDataType(const std::string& rPath) const;
 
    bool HasFloatDataType(const std::string& rPath) const;
 
    template<class TDataType>
    bool HasDataType(const std::string& rPath) const;
 
    void Flush();
 
    void Close();
 
    unsigned GetFileSize() const;
 
    std::string GetFileName() const;
 
    int GetEchoLevel() const;
 
    void SetEchoLevel(int Level);
 
    const DataCommunicator& GetDataCommunicator() const;
 
    unsigned GetPID() const;
 
    unsigned GetTotalProcesses() const;
 
    template<class TDataType>
    void ReadAttribute(
        const std::string& rObjectPath,
        const std::string& rName,
        TDataType& rValue) const;
 
    Parameters ReadAttribute(const std::string& rObjectPath) const;
 
    template<class TDataType>
    void ReadDataSet(
        const std::string& rPath,
        TDataType& rData,
        const unsigned StartIndex,
        const unsigned BlockSize) const;
 
    template<class TDataType>
    void ReadDataSetIndependent(
        const std::string& rPath,
        TDataType& rData,
        const unsigned StartIndex,
        const unsigned BlockSize) const;
 
    unsigned GetOpenObjectsCount() const;
 
private:
 
    DataCommunicator const * mpDataCommunicator;
 
    std::string mFileName;
 
    hid_t mFileId = -1; // Default invalid file id.
 
    int mEchoLevel = 0;
 
 
 
    void SetFileDriver(
        const std::string& rDriver,
        hid_t FileAccessPropertyListId) const;
 
    hid_t GetFileId() const;
 
    hid_t OpenExistingDataSet(const std::string& rPath);
 
    template<class TDataType, DataTransferMode TDataTransferMode>
    void WriteDataSetImpl(
        const std::string& rPath,
        const TDataType& rData,
        WriteInfo& rInfo);
 
    template<class TDataType, DataTransferMode TDataTransferMode>
    void ReadDataSetImpl(
        const std::string& rPath,
        TDataType& rData,
        const unsigned StartIndex,
        const unsigned BlockSize) const;
 
};
 
 
namespace Internals
{
 
bool IsPath(const std::string& rPath);
 
std::vector<std::string> Split(const std::string& rPath, char Delimiter);
 
std::vector<hsize_t> GetDataDimensions(const Vector<int>& rData);
std::vector<hsize_t> GetDataDimensions(const Vector<double>& rData);
std::vector<hsize_t> GetDataDimensions(const Vector<array_1d<double, 3>>& rData);
std::vector<hsize_t> GetDataDimensions(const Matrix<int>& rData);
std::vector<hsize_t> GetDataDimensions(const Matrix<double>& rData);
std::vector<hsize_t> GetDataDimensions(const File& rFile, const std::string& rPath);
} // namespace Internals.
 
} // namespace HDF5.
} // namespace Kratos.