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 "../schnek_config.hpp"
#ifdef SCHNEK_HAVE_HDF5

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

#include <hdf5.h>

namespace schnek {

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;
};

class HdfStream {
  protected:
    hid_t       file_id;

    herr_t      status;

    std::string blockname;
    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_);
    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 {
  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;
  public:
    HdfOStream();

    HdfOStream(const HdfOStream&);

    HdfOStream(const char* fname);

    int open(const char*);

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

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

template<typename Type, typename PointerType = boost::shared_ptr<Type>, class DiagnosticType = IntervalDiagnostic >
class HDFGridDiagnostic : public SimpleDiagnostic<Type, PointerType, DiagnosticType> {
  protected:
    HdfOStream output;
    GridContainer<Type> container;
  protected:
    typedef typename Type::IndexType IndexType;
    void open(const std::string &);
    void write();
    void close();
    void init();
    virtual IndexType getGlobalMin() = 0;
    virtual IndexType getGlobalMax() = 0;
  public:
    virtual ~HDFGridDiagnostic() {}
};

} // namespace schnek

#include "hdfdiagnostic.t"

#endif

#endif // SCHNEK_HDFDIAGNOSTIC_HPP_