Hdf5File.h

Go to the documentation of this file.

#ifndef HDF5FILE_H_INCLUDED
#define HDF5FILE_H_INCLUDED
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "sim/SimState.h"

#ifdef USE_HDF5
#include <list>
#include <string>
#include <vector>
#include <hdf5.h>
#include <boost/property_tree/ptree.hpp>

namespace SimPT_Sim {
        class Sim;
}

namespace SimPT_Shell {

class Hdf5File
{
public:
        Hdf5File();

        Hdf5File(const std::string& file_path);

        virtual ~Hdf5File();

        bool Close();

        static std::string GetFileExtension();

        std::string GetFilePath();

        static bool HDF5Available() { return true; }

        bool IsOpen();

        bool Open(const std::string& file_path);

        // TODO: document!
        SimPT_Sim::SimState Read(int step_idx = -1);

        std::vector<std::pair<int, double>> TimeSteps();

        void Write(std::shared_ptr<const SimPT_Sim::Sim> sim);

private:
        void ReadBPNodes(hid_t loc_id, SimPT_Sim::MeshState& mstate);

        void ReadBPWalls(hid_t loc_id, SimPT_Sim::MeshState& mstate);

        void ReadCells(hid_t loc_id, SimPT_Sim::MeshState& mstate);

        void ReadNodes(hid_t loc_id, SimPT_Sim::MeshState& mstate);

        boost::property_tree::ptree ReadParameters(hid_t loc_id);

        boost::property_tree::ptree ReadPtreeFromStringAttribute(hid_t loc_id, const std::string& attr_name);

        void ReadWalls(hid_t loc_id, SimPT_Sim::MeshState& mstate);

        void WriteBPNodes(hid_t loc_id, const SimPT_Sim::MeshState& mstate);

        void WriteBPWalls(hid_t loc_id, const SimPT_Sim::MeshState& mstate);

        void WriteCells(hid_t loc_id, const SimPT_Sim::MeshState& mstate);

        void WriteMesh(hid_t loc_id, const SimPT_Sim::MeshState& mstate);

        void WriteNodes(hid_t loc_id, const SimPT_Sim::MeshState& mstate);

        void WriteParameters(hid_t loc_id, const boost::property_tree::ptree& params);

        void WritePtreeToStringAttribute(hid_t loc_id, const std::string& attr_name, boost::property_tree::ptree const& pt);

        void WriteState(const SimPT_Sim::SimState& s);

        void WriteWalls(hid_t loc_id, const SimPT_Sim::MeshState& mstate);

private:
        hid_t           m_file_id;              
        std::string     m_file_path;            
};

} // end namespace VirtualLeaf

// Fallback code in case libhdf5 is not available on this platform
#else

#include "bio/Mesh.h"
#include <iostream>
#include <string>

#pragma GCC diagnostic ignored "-Wunused-parameter"

namespace SimPT_Sim {
        class Sim;
}

namespace SimPT_Shell {

class Hdf5File
{
public:
        Hdf5File()
        {
                std::cout << "[HDF5] Warning: HDF5 must be enabled at compile time." << std::endl;
        }
        Hdf5File(std::string const&)
        {
                std::cout << "[HDF5] Warning: HDF5 must be enabled at compile time." << std::endl;
        }
        virtual ~Hdf5File() {}

        bool Close() { return true; }

        std::string static GetFileExtension() {return "h5";}

        std::string GetFilePath() {return "";}

        static bool HDF5Available() { return false; }

        bool IsOpen() { return true; }

        bool Open(const std::string& ) { return true; }

        void Write(std::shared_ptr<const SimPT_Sim::Sim> ) {}

        SimPT_Sim::SimState Read(int step = -1) {return SimPT_Sim::SimState(); }

        std::vector<std::pair<int, double>> TimeSteps() { return {}; }
};

} // namespace

#endif /* USE_HDF5 */

#endif // end_of_include guard