hdfdiagnostic.hpp

/*
 * hdfdiagnostic.hpp
 *
 * Created on: 23 Oct 2012
 * Author: hschmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek 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.
 *
 * Schnek 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 Schnek.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef SCHNEK_HDFDIAGNOSTIC_HPP_
#define SCHNEK_HDFDIAGNOSTIC_HPP_

#include "../config.hpp"
#ifdef SCHNEK_HAVE_HDF5

#include "../grid/grid.hpp"
#include "diagnostic.hpp"

#include <hdf5.h>

#include <memory>

#if defined (H5_HAVE_PARALLEL) && defined (SCHNEK_USE_HDF_PARALLEL)
#include <mpi.h>
#endif

#include <map>

namespace schnek {

template<typename TYPE>
struct H5DataType{
  static const hid_t type;
};


template<typename FieldType>
struct GridContainer
{
  FieldType grid;

  typename FieldType::IndexType global_min;

  typename FieldType::IndexType global_max;

  typename FieldType::IndexType local_min;

  typename FieldType::IndexType local_max;
};

struct HdfAttributes {
  friend class HdfOStream;
  private:
    struct Info {
      hid_t type;
      hsize_t dims;
      const void *buffer;
    };
    typedef std::shared_ptr<Info> pInfo;

    std::map<std::string, pInfo> attributes;
  public:

    template<typename T>
    void set(std::string name, const T *value, hsize_t dims = 1);

    template<typename T>
    void set(std::string name, const T &value, hsize_t dims = 1);
};

typedef std::shared_ptr<HdfAttributes> pHdfAttributes;

class HdfStream {
  protected:
    hid_t       file_id;

    herr_t      status;

    std::string blockname;

    pHdfAttributes attributes;

    int sets_count;

    bool active;
    bool activeModified;

  public:
    HdfStream();
    HdfStream(const HdfStream&);
    virtual ~HdfStream();

    virtual int open(const char*)=0;

    virtual void close();

    virtual bool good() const;

    void setBlockName(std::string blockname_);

    void setAttributes(pHdfAttributes attributes_);

    HdfStream& operator = (const HdfStream&);

    void setActive(bool active_) { active = active_; activeModified = true; }

  protected:
    std::string getNextBlockName();

#if defined (H5_HAVE_PARALLEL) && defined (SCHNEK_USE_HDF_PARALLEL)
    void makeMPIGroup();

    MPI_Comm mpiComm;
    bool commSet;
#endif

};


class HdfIStream : public HdfStream {
  private:
    hid_t dxpl_id;
  public:
    HdfIStream();

    HdfIStream(const HdfIStream&);

    HdfIStream(const char* fname);

    int open(const char*);

    template<typename FieldType>
    void readGrid(GridContainer<FieldType> &g);
};


class HdfOStream : public HdfStream {
  private:
    hid_t dxpl_id;
#if defined (H5_HAVE_PARALLEL) && defined (SCHNEK_USE_HDF_PARALLEL)
    MPI_Info mpi_info;
#endif
    hid_t plist_id;
    bool initialised;
  public:
    HdfOStream();

    HdfOStream(const HdfOStream&);

    HdfOStream(const char* fname);

    int open(const char*);

    template<typename FieldType>
    void writeGrid(GridContainer<FieldType> &g);
};
template<typename Type, class DiagnosticType = IntervalDiagnostic >
class HDFGridDiagnostic : public SimpleDiagnostic<Type, Type, DiagnosticType> {
  public:
    typedef typename Type::IndexType IndexType;
  protected:
    HdfOStream output;
    GridContainer<Type> container;
  protected:
    void open(const std::string &);
    void write();
    void close();

    void init();
    virtual IndexType getGlobalMin() = 0;
    virtual IndexType getGlobalMax() = 0;

    virtual std::string getDatasetName();

    virtual pHdfAttributes getAttributes() {
      return std::make_shared<HdfAttributes>();
    };
  public:
    virtual ~HDFGridDiagnostic() {}
};

template<typename Type>
class HDFGridReader : public Block
{
  public:
    typedef typename Type::IndexType IndexType;
  protected:
    HdfIStream input;
    GridContainer<Type> container;
    Type field;
    std::string fieldName;
    std::string fileName;
  public:
    HDFGridReader();
    virtual ~HDFGridReader() {}
  protected:
    void open();

    void read();

    void close();

    void execute();

    void init();

    virtual IndexType getGlobalMin() = 0;

    virtual IndexType getGlobalMax() = 0;

    virtual std::string getDatasetName();

    void initParameters(BlockParameters &blockPars);
};

} // namespace schnek

#include "hdfdiagnostic.t"

#endif

#endif // SCHNEK_HDFDIAGNOSTIC_HPP_