OutputVTKHDF.h

Go to the documentation of this file.

//
//       ,---.     ,--,    .---.     ,--,    ,---.    .-. .-.
//       | .-'   .' .')   / .-. )  .' .'     | .-'    |  \| |
//       | `-.   |  |(_)  | | |(_) |  |  __  | `-.    |   | |
//       | .-'   \  \     | | | |  \  \ ( _) | .-'    | |\  |
//       |  `--.  \  `-.  \ `-' /   \  `-) ) |  `--.  | | |)|
//       /( __.'   \____\  )---'    )\____/  /( __.'  /(  (_)
//      (__)              (_)      (__)     (__)     (__)
//      Official webSite: https://code-mphi.github.io/ECOGEN/
//
//  This file is part of ECOGEN.
//
//  ECOGEN is the legal property of its developers, whose names
//  are listed in the copyright file included with this source
//  distribution.
//
//  ECOGEN is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published
//  by the Free Software Foundation, either version 3 of the License,
//  or (at your option) any later version.
//
//  ECOGEN is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with ECOGEN (file LICENSE).
//  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef OUTPUTVTKHDF_H_
#define OUTPUTVTKHDF_H_
 
#include <hdf5.h>
 
#include "Output.h"
 
class OutputVTKHDF : public Output
{
  public:
    OutputVTKHDF(std::string casTest, std::string run, tinyxml2::XMLElement* element, std::string fileName, Input* entree);
    OutputVTKHDF(std::string nameRun, int fileNumberRestartMeshMapping, Input* input, const H5FD_mpio_xfer_t& transfer_mode);
    ~OutputVTKHDF() override;
 
    virtual void initializeSpecificOutput() override;
    virtual void writeResults(Mesh* mesh, std::vector<Cell*>* cellsLvl) override;
    virtual void readResults(Mesh* mesh, std::vector<Cell*>* cellsLvl, int cpu = -1) override;

    virtual const void* getTransferMode() const override { return (void*)&m_transfer_mode; }
 
  protected:
    // restarting a simulation with mesh mapping. This method gather the code needed by both constructors: the output type assignement and the
    // setting of the main hdf5 properties.
    void initializeProperties(const H5FD_mpio_xfer_t& transfer_mode);

    int readScalarVTKHDF(hid_t group_id, const std::string& dataset_name, std::vector<size_t>& scalar_array) const;

    template <size_t N>
    int readArrayVTKHDF(
      hid_t group_id, std::string dataset_name, std::vector<double>& dataset, const hsize_t (&local_dims)[N], const hsize_t (&offsets)[N]);

    template <size_t N>
    int ReadPhysicalDataVTKHDF(
      Mesh* mesh, std::vector<Cell*>* cellsLvl, hid_t group_id, const hsize_t (&count_scalar)[N], const hsize_t (&start_scalar)[N]);

    int ReadPhysicalDataVTKHDF(Mesh* mesh, std::vector<Cell*>* cellsLvl, hid_t group_id, int cpu, const std::vector<size_t>& numberCells);
 
    std::string createFilenameVTKHDF(const char* name, int numFile = -1, std::string nameVariable = "defaut") const;

    int openFileVTKHDF(hid_t& file_id, bool parallel_access, bool create) const;

    void writeTimeseriesVTKHDF(int numFile);

    void writeXDMF(Mesh* mesh, int numFile);

    static void writeDataXDMF(std::ofstream& fileStream,
                              const std::string& dataFile,
                              const std::string& dataName,
                              const std::string& dataType,
                              int numberCellsX,
                              int numberCellsY,
                              int numberCellsZ,
                              int dimData);

    void writeResultsVTKHDF(Mesh* mesh, std::vector<Cell*>* cellsLvl);

    int writePhysicalDataVTKHDF(hid_t& file, const Mesh* mesh, std::vector<Cell*>* cellsLvl, hid_t& vtkhdf_group_id, size_t numberCells) const;

    template <size_t N, typename T>
    int writePhysicalDataVTKHDF(const Mesh* mesh,
                                std::vector<Cell*>* cellsLvl,
                                hid_t vtkhdf_group_id,
                                size_t numberCells,
                                const hsize_t (&dimsf_scalar)[N],
                                const hsize_t (&count_scalar)[N],
                                const hsize_t (&start_scalar)[N],
                                const hsize_t (&chunk_scalar)[N]) const;

    int writeScalarVTKHDF(const hid_t& group_id, const std::string& dataset_name, const size_t& scalar_val) const;

    static void unstructuredFirstRangeLayout(const size_t& line_count, hsize_t* dimsf, hsize_t* count, hsize_t* start);

    const void* getOutputBuffer(const std::vector<double>& double_buffer, std::vector<float>& float_buffer) const;
 
    template <typename T>
    int writeConnectivity(Mesh* mesh, std::vector<Cell*>* cellsLvl, hid_t& vtkhdf_group_id, size_t& numberCells, const size_t& numberNodes) const;

    template <typename T>
    int writeUnstructuredArrayVTKHDF(const hid_t& group_id,
                                     const std::string& dataset_name,
                                     hid_t hdf_file_dtype,
                                     hid_t hdf_mem_dtype,
                                     const std::vector<T>& dataset,
                                     const size_t& line_count,
                                     size_t column_count = 1) const;

    template <size_t N, typename T>
    int writeArrayVTKHDF(const hid_t& group_id,
                         const std::string& dataset_name,
                         hid_t hdf_mem_dtype,
                         hid_t hdf_file_dtype,
                         hid_t parallel_x_properties,
                         const std::vector<T>& dataset,
                         const hsize_t (&global_dims)[N],
                         const hsize_t (&local_dims)[N],
                         const hsize_t (&offsets)[N],
                         const hsize_t (&chunk_dims)[N]) const;

    int writeArrayAttribute(const hid_t& group_id, const std::string& attribute_name, const hsize_t& nitem, const int* array) const;

    int writeHeaderVTKHDF(const hid_t& group_id, const std::string& mesh_type) const;
 
    // Depends on mesh type

    // https://discourse.vtk.org/t/support-for-rectilineargrids-and-structuredgrids-in-vtkhdf-file-format/14283/6
    // An additional xmdf file is required for Paraview to interpret data.
    int writeMeshRectilinearVTKHDF(Mesh* mesh, hid_t& file, hid_t& vtkhdf_group_id, size_t& numberCells);

    int writeMeshUnstructuredVTKHDF(Mesh* mesh, std::vector<Cell*>* cellsLvl, hid_t& file, hid_t& vtkhdf_group_id, size_t& numberCells) const;
 
    void writeDataset(std::vector<double> /*dataset*/, std::ofstream& /*fileStream*/, TypeData /*typeData*/) const
    {
      throw ErrorECOGEN("'writeDataset' not available for VTKHDF output format: use 'writeArrayVTKHDF' instead.");
    };
 
    static void getDataset(std::istringstream& /*data*/, std::vector<double>& /*dataset*/)
    {
      throw ErrorECOGEN("'getDataset' not available for VTKHDF output format: use 'readArrayVTKHDF' instead.");
    };
 
    virtual void prepareErrorFiles() const override;
    virtual void writeErrorInFile(std::vector<Errors>& v, const int& ErrorType, const int& iteration, bool& warn) const override;
    virtual void printTree(Mesh* mesh, const std::vector<Cell*>* cellsLvl, int m_resumeAMRsaveFreq) const override;
 
    virtual void readTree(Mesh* mesh,
                          TypeMeshContainer<Cell*>* cellsLvl,
                          TypeMeshContainer<Cell*>* cellsLvlGhost,
                          TypeMeshContainer<CellInterface*>* const cellInterfacesLvl,
                          const std::vector<AddPhys*>& addPhys,
                          int& nbCellsTotalAMR) override;
 
  private:
    hid_t m_h5_file_floatType; 
    hid_t m_h5_file_intType;   
 
    hid_t m_h5_mem_floatType; 
    hid_t m_h5_mem_intType; 
 
    hid_t m_group_creation_properties;   
    hid_t m_dataset_creation_properties; 
    hid_t m_parallel_x_properties;       
 
    H5FD_mpio_xfer_t m_transfer_mode; 
 
    static constexpr size_t DIM_OUTPUT{3};           
    static constexpr int VTKHDF_VERSION[2] = {2, 4}; 
    static constexpr int ERROR_VALUE       = -1;     
    static constexpr int SUCCESS_VALUE     = 0;      
};
 
#endif // OUTPUTVTKHDF_H_