EpetraExt_HDF5.h

Go to the documentation of this file.

//@HEADER
// ***********************************************************************
//
//     EpetraExt: Epetra Extended - Linear Algebra Services Package
//                 Copyright (2001) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
//@HEADER

#ifndef EPETRAEXT_HDF5_H
#define EPETRAEXT_HDF5_H

#include "EpetraExt_ConfigDefs.h"
#ifdef HAVE_EPETRAEXT_HDF5

#include "hdf5.h"
class Epetra_Map;
class Epetra_BlockMap;
class Epetra_Comm;
class Epetra_IntVector;
class Epetra_MultiVector;
class Epetra_CrsGraph;
class Epetra_RowMatrix;
class Epetra_CrsMatrix;
class Epetra_VbrMatrix;
namespace Teuchos {
  class ParameterList;
}
namespace EpetraExt {
  class Handle;
  template<class T>
  class DistArray;
}

namespace EpetraExt 
{
class HDF5 
{
  public: 
    // @{ \name Constructor and destructor.
    HDF5(const Epetra_Comm& Comm); 

    ~HDF5() 
    {
      if (IsOpen())
        Close();
    }

    // @}
    // @{ \name Basic operations
    
    void Create(const string FileName);

    void Open(const string FileName, int AccessType = H5F_ACC_RDWR);

    void Close()
    {
      H5Fclose(file_id_);
      IsOpen_ = false;
    }
    
    void Flush()
    {
      H5Fflush(file_id_, H5F_SCOPE_GLOBAL);
    }

    bool IsOpen() const
    {
      return(IsOpen_);
    }

    void CreateGroup(const string& GroupName)
    {
      hid_t group_id = H5Gcreate(file_id_, GroupName.c_str(), 0, H5P_DEFAULT, H5P_DEFAULT);
      H5Gclose(group_id);
    }

    bool IsContained(const string Name);

    // @}
    // @{ \name basic non-distributed data types
    
    void Write(const string& GroupName, const string& DataSetName, int data);

    void Read(const string& GroupName, const string& DataSetName, int& data);

    void Write(const string& GroupName, const string& DataSetName, double data);

    void Read(const string& GroupName, const string& DataSetName, double& data);

    void Write(const string& GroupName, const string& DataSetName, const string& data);

    void Read(const string& GroupName, const string& DataSetName, string& data);

    void Read(const string& GroupName, const string& DataSetName,
              const int type, const int Length, void* data);

    void Write(const string& GroupName, const string& DataSetName,
                         const int type, const int Length, 
                         void* data);

    void WriteComment(const string& GroupName, string Comment)
    {
      H5Gset_comment(file_id_, GroupName.c_str(), Comment.c_str());
    }

    void ReadComment(const string& GroupName, string& Comment)
    {
      char comment[128];
      H5Gget_comment(file_id_, GroupName.c_str(), 128, comment);
      Comment = comment;
    }

    // @}
    // @{ \name Distributed arrays
    
    void Write(const string& GroupName, const string& DataSetName, int MySize, int GlobalSize, int type, const void* data);

    void Read(const string& GroupName, const string& DataSetName,
              int MySize, int GlobalSize,
              const int type, void* data);

    // @}
    // @{ \name Epetra_Map/Epetra_BlockMap

    void Write(const string& GroupName, const Epetra_Map& Map);

    void Read(const string& GroupName, Epetra_Map*& Map);

    void ReadMapProperties(const string& GroupName, 
                           int& NumGlobalElements,
                           int& IndexBase,
                           int& NumProc);

    void Read(const string& GroupName, Epetra_BlockMap*& Map);

    void Write(const string& GroupName, const Epetra_BlockMap& Map);

    void ReadBlockMapProperties(const string& GroupName, 
                                int& NumGlobalElements,
                                int& NumGlobalPoints,
                                int& IndexBase,
                                int& NumProc);

    // @}
    // @{ \name Epetra_CrsGraph

    void Read(const string& GroupName, Epetra_CrsGraph*& Graph);

    void Read(const string& GroupName, const Epetra_Map& DomainMap, 
              const Epetra_Map& RangeMap, Epetra_CrsGraph*& Graph);

    void Write(const string& GroupName, const Epetra_CrsGraph& Graph);

    void ReadCrsGraphProperties(const string& GroupName, 
                                int& NumGlobalRows,
                                int& NumGlobalCols,
                                int& NumGlobalNonzeros,
                                int& NumGlobalDiagonals,
                                int& MaxNumIndices);

    // @}
    // @{ \name Epetra_IntVector

    void Write(const string& GroupName, const Epetra_IntVector& x);

    void Read(const string& GroupName, Epetra_IntVector*& X);

    void Read(const string& GroupName, const Epetra_Map& Map, Epetra_IntVector*& X);

    void ReadIntVectorProperties(const string& GroupName, int& GlobalLength);

    // @}
    // @{ \name Epetra_MultiVector

    void Write(const string& GroupName, const Epetra_MultiVector& x, bool writeTranspose = false);

    void Read(const string& GroupName, Epetra_MultiVector*& X,
              bool writeTranspose = false, const int& indexBase = 0);

    void Read(const string& GroupName, const Epetra_Map& Map, Epetra_MultiVector*& X,
              bool writeTranspose = false);

    void ReadMultiVectorProperties(const string& GroupName, 
                                   int& GlobalLength,
                                   int& NumVectors);

    // @}
    // @{ \name Epetra_RowMatrix/Epetra_CrsMatrix

    void Write(const string& GroupName, const Epetra_RowMatrix& Matrix);

    void Read(const string& GroupName, Epetra_CrsMatrix*& A);

    void Read(const string& GroupName, 
              const Epetra_Map& DomainMap, 
              const Epetra_Map& RangeMap, 
              Epetra_CrsMatrix*& A);

    void ReadCrsMatrixProperties(const string& GroupName, 
                                 int& NumGlobalRows,
                                 int& NumGlobalCols,
                                 int& NumNonzeros,
                                 int& NumGlobalDiagonals,
                                 int& MaxNumEntries,
                                 double& NormOne,
                                 double& NormInf);

    // @}
    // @{ \name Teuchos::ParameterList

    void Write(const string& GroupName, const Teuchos::ParameterList& List);

    void Read(const string& GroupName, Teuchos::ParameterList& List);

    // @}
    // @{ \name EpetraExt::DistArray<int>

    void Write(const string& GroupName, const DistArray<int>& array);

    void Read(const string& GroupName, DistArray<int>*& array);

    void Read(const string& GroupName, const Epetra_Map& Map, DistArray<int>*& array);

    void ReadIntDistArrayProperties(const string& GroupName, 
                                    int& GlobalLength,
                                    int& RowSize);

    // @}
    // @{ \name EpetraExt::DistArray<double>

    void Write(const string& GroupName, const DistArray<double>& array);

    void Read(const string& GroupName, DistArray<double>*& array);

    void Read(const string& GroupName, const Epetra_Map& Map, DistArray<double>*& array);

    void ReadDoubleDistArrayProperties(const string& GroupName, 
                                       int& GlobalLength,
                                       int& RowSize);
    // @}
    // @}
    // @{ \name Generic distributed object

    void Write(const string& GroupName, const Handle& List);

    void Read(const string& GroupName, Handle& List);

    void ReadHandleProperties(const string& GroupName, 
                              string& Type,
                              int& NumGlobalElements);

    // @}
  private:
    // @{ \name Private Data

    const Epetra_Comm& Comm() const
    {
      return(Comm_);
    }

    const Epetra_Comm& Comm_; 
    string FileName_;
    bool IsOpen_;

    hid_t       file_id_;
    hid_t plist_id_;
    herr_t  status;

    // @}
};
}
#endif
#endif /* EPETRAEXT_HDF5_H */