EpetraExt_HDF5.h

Go to the documentation of this file.

//@HEADER
// ***********************************************************************
//
//     EpetraExt: Epetra Extended - Linear Algebra Services Package
//                 Copyright (2011) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// 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 <string>
#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 std::string FileName);

    void Open(const std::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 std::string& GroupName)
    {
      hid_t group_id = H5Gcreate(file_id_, GroupName.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
      H5Gclose(group_id);
    }

    bool IsContained(std::string Name, std::string GroupName = "");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // @}
    // @{ \name Epetra_CrsGraph

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

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

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

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

    // @}
    // @{ \name Epetra_IntVector

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

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

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

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

    // @}
    // @{ \name Epetra_MultiVector

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    const Epetra_Comm& Comm_; 
    std::string FileName_;
    bool IsOpen_;

    hid_t       file_id_;
    hid_t plist_id_;
    herr_t  status;

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