mdal_xdmf.hpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2019 Peter Petrik (zilolv at gmail dot com)
*/
 
#ifndef MDAL_XDMF_HPP
#define MDAL_XDMF_HPP
 
#include <string>
#include <vector>
#include <memory>
#include <iosfwd>
#include <iostream>
#include <fstream>
#include <utility>
 
#include "mdal_data_model.hpp"
#include "mdal.h"
#include "mdal_hdf5.hpp"
#include "mdal_driver.hpp"
#include "mdal_xml.hpp"
 
namespace MDAL
{
 
  struct HyperSlab
  {
    size_t startX = 0; // offset X
    size_t startY = 0; // offset Y
    size_t count = 0; // number of cells/vertices
    bool countInFirstColumn = true;
    bool isScalar;
  };
 
  class XdmfDataset: public Dataset2D
  {
    public:
      XdmfDataset( DatasetGroup *grp,
                   const HyperSlab &slab,
                   const HdfDataset &valuesDs,
                   MDAL::RelativeTimestamp time
                 );
      ~XdmfDataset() override;
 
      size_t scalarData( size_t indexStart, size_t count, double *buffer ) override;
      size_t vectorData( size_t indexStart, size_t count, double *buffer ) override;
 
    private:
      std::vector<hsize_t> offsets( size_t indexStart );
      std::vector<hsize_t> selections( size_t copyValues );
 
      HdfDataset mHdf5DatasetValues;
      HyperSlab mHyperSlab;
  };
 
  class XdmfFunctionDataset: public Dataset2D
  {
    public:
      enum FunctionType
      {
        Join = 1, 
        Subtract, 
        Flow, 
      };
 
      XdmfFunctionDataset( DatasetGroup *grp,
                           FunctionType type,
                           const RelativeTimestamp &time
                         );
      ~XdmfFunctionDataset() override;
 
      void addReferenceDataset( const HyperSlab &slab, const HdfDataset &hdfDataset, const RelativeTimestamp &time );
      void swap();
 
      size_t scalarData( size_t indexStart, size_t count, double *buffer ) override;
      size_t vectorData( size_t indexStart, size_t count, double *buffer ) override;
 
    private:
      size_t subtractFunction( size_t indexStart, size_t count, double *buffer );
      size_t flowFunction( size_t indexStart, size_t count, double *buffer );
      size_t joinFunction( size_t indexStart, size_t count, double *buffer );
      size_t extractRawData( size_t indexStart, size_t count, size_t nDatasets, std::vector<double> &buf );
 
      const FunctionType mType;
      std::vector<std::shared_ptr<XdmfDataset>> mReferenceDatasets;
      DatasetGroup mBaseReferenceGroup;
  };
 
  class DriverXdmf: public Driver
  {
    public:
      DriverXdmf();
      ~DriverXdmf( ) override;
      DriverXdmf *create() override;
 
      bool canReadDatasets( const std::string &uri ) override;
      void load( const std::string &datFile, Mesh *mesh ) override;
 
    private:
      DatasetGroups parseXdmfXml( );
 
      std::shared_ptr<MDAL::DatasetGroup> findGroup( std::map< std::string, std::shared_ptr<MDAL::DatasetGroup> > &groups,
          const std::string &groupName,
          bool isScalar );
 
      std::pair<HdfDataset, HyperSlab > parseXdmfDataset( const XMLFile &xmfFile, xmlNodePtr itemNod );
 
      HyperSlab parseHyperSlab( const std::string &str, size_t dimB );
 
      HyperSlab parseHyperSlabNode( const XMLFile &xmfFile, xmlNodePtr node );
 
      HdfDataset parseHdf5Node( const XMLFile &xmfFile, xmlNodePtr node );
 
      void hdf5NamePath( const std::string &dataItemPath, std::string &filePath, std::string &hdf5Path );
 
      std::vector<size_t> parseDimensions2D( const std::string &data );
 
      MDAL::Mesh *mMesh = nullptr;
      std::string mDatFile;
      std::map< std::string, std::shared_ptr<HdfFile> > mHdfFiles;
 
  };
 
} // namespace MDAL
#endif //MDAL_XDMF_HPP