matfileIO.hh

Go to the documentation of this file.

 
#ifndef matfileInputOutput_hh
#define matfileInputOutput_hh
 
#include <string>
#include <typeinfo>
 
#include "matIO_1.5/matio.h" // <matio.h>
#include "basics.hh"
#include "toolbox.hh"
#include "operator.hh"
#include <toolbox/sharedPointer.hh>
#include <basics/exceptions.hh>
 
namespace concepts {
 
  typedef std::set<const std::type_info*> set_info;
 
  // forward declaration
  class MatfileIO;
 
  // **************************************************** MatfileIOError **
 
  class MatfileIOError: public ExceptionBase {
  public:
    MatfileIOError(const std::string& file, const unsigned int line, 
                   const std::string& function,
                   const std::string& errorMessage) throw ();
  
    virtual const char* what() const throw();
    
    virtual ~MatfileIOError() throw () {};
  protected:
    virtual std::ostream& info(std::ostream& os) const throw ();
  private:
    std::string errorMessage_;
    mutable std::string outputMessage_ ;
  };
 
  // ********************************************************* MatfileIO **
 
 
 
  //
  //  TODO: VALGRIND !
  //  @test test::MatfileTest
  //
 
 
 
  //############################################################ Introduction to update this class
  //
  //  To add new dense/sparse objects (rank <= 2) to for add/get -routines. Do the following:
  //    -> Write new get_/add_ routine for the object (matfileIO_C /matfileIO_R for Cmplx/Real based ones)
  //    -> Write necessary assertion routines if needed,
  //
  //  To generalise this class to rank > 2 objects (cubes, general multi-arrays) it could be a good idea to add a assertRank_
  //  routine in the get routines.
  //
  //  This class works with dense/sparse/int formats.To write *.mat-files with structs/ cells data,
  //  check the documentation of matIO and add needed functions.
  //
  //############################################################
 
 
 
  class MatfileIO : public OutputOperator{
  public:
 
    MatfileIO(const std::string filename);
 
    /*
     * The deconstructor closes the MatfileIO instance if it is still open.
     */
    virtual ~MatfileIO() {
      close();
    }
 
    template<class T>
    void add(const T& u, const std::string varName,
             enum matio_compression compress = MAT_COMPRESSION_NONE) throw (MatfileIOError) {
 
 
      if (!isOpen()) {
        throw conceptsException(MatfileIOError(__FILE__, __LINE__, __FUNCTION__, "Cannot add something. No *.mat-file opened."));
        return;
      }
 
      //The var is currently being written in the open stream.
      if (matvar_str_cur_.exist(varName)) {
        throw conceptsException(MatfileIOError(__FILE__, __LINE__, __FUNCTION__, "Not able to add : a variable with the same name is being added currently. Close the MatfileIO and retry again with overwrite rights."));
        return;
      }
      //The var already exists in the opened matfile and will be overwritten:
      else if (matvar_str_.exist(varName)) {
        if (overWrite_) {
          remove(varName);
          //it gets a variable used in the current set;
          matvar_str_cur_.insert(varName);
 
#ifdef HAS_Z  // if z lib is installed you can use the compression given
          add_(u, varName, compress);
#else         // if not by default no compression is applicated
          add_(u, varName, MAT_COMPRESSION_NONE);
#endif
          return;
        } else {
          throw conceptsException(MatfileIOError(__FILE__, __LINE__, __FUNCTION__, " The variable '" + varName + "' has been declared not to be overwritten."));
        }
      } else if (!matvar_str_.exist(varName)) {
        matvar_str_.insert(varName);
        matvar_str_cur_.insert(varName);
#ifdef HAS_Z  // if z lib is installed you can use the compression given
        add_(u, varName, compress);
#else     // if not by default no compression is applicated
        add_(u, varName, MAT_COMPRESSION_NONE);
#endif
        return;
      }
      // just to be sure
      throw conceptsException(MatfileIOError(__FILE__, __LINE__, __FUNCTION__, "Some unhandled/ unknown error arisen in add-Routine in MatfileIO."));
      return;
    }
 
    template<class T>
    void get(T& u, const std::string varName) throw (MatfileIOError, MissingFeature) {
 
      //for sparse, int and uint use Mat_VarRead method, so structure = 1, (structure = 0, ie. for dense)
      bool structure = isSparse(varName) || isInt(varName) || isUint(varName);
 
 
      // isSparse checks also for existence of varName.
      // for Sparse Format the Mat_VarReadinfo is not working with mat_sparse_t pointer
      // so read with Mat_VarRead is used. Here it has no problems with reading compressed format.
      // for integer format, needed to access data pointer.
      matvar_ = structure ?  Mat_VarRead(mat_, varName.c_str()): Mat_VarReadInfo(mat_, varName.c_str()) ;
 
      //check if reading works
      assertVar_(matvar_);
 
      //Multidimensional Arrays, i.e. rank > 2 are not supported atm.
      if (matvar_->rank > 2)
        throw concepts::MissingFeature(
                                       "At the moments just rank 2 objects are supported in MatfileIO");
 
      //get_ routine checks if requested structure coincides with the one of u (dense/sparse)
      get_(u, matvar_);
    }
 
    void reopen();
 
    void close();
 
    void clear();
 
    inline bool isOpen() const {
      return (mat_ != NULL);
    }
 
    inline bool isEmpty() const {
      return (matvar_str_.isempty());
    }
 
    bool remove(const std::string varName);
 
    inline std::string filename() const {
      return fileName_;
    }
 
    inline void overWrite(bool toOverWrite) {
      overWrite_ = toOverWrite;
    }
 
    //##################################################################
    //                public control routines
    //##################################################################
 
    bool exists(const std::string& varName) const;
 
    bool isReal(const std::string& varName) const;
 
    bool isCmplx(const std::string& varName) const;
 
    bool isScalar(const std::string& varName) const;
 
    bool isDense(const std::string& varName) const;
 
    bool isSparse(const std::string& varName) const;
 
    bool isInt(const std::string& varName) const;
 
    bool isUint(const std::string& varName) const;
 
    uint lengthVector(const std::string& varName) const;
 
    //  /*
    //   * Returns true if the variable /c varName is a cell, else 0.
    //   */
    //  bool isCell(const std::string& varName) const;
 
 
    //##################################################################
    //                public assertion routines
    //##################################################################
    void assertCmplx(const std::string& varName) const throw (MatfileIOError);
    void assertExistence(const std::string& varName) const throw (MatfileIOError);
 
    void assertVector(const std::string& varName) const throw (MatfileIOError);
 
    void assertQuadratic(const std::string& varName) const throw (MatfileIOError);
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
  private:
 
    //the current Matfile
    mat_t* mat_;
    //the current variable in the Matfile
    matvar_t* matvar_;
 
    //name of the current open *.mat-file
    std::string fileName_;
 
    //collection of all names of the variables in the current mat-file
    concepts::Set<std::string> matvar_str_;
 
    //collection of all names of variables that are going to be added in the current mat-file-stream
    //this is used to avoid adding different objects with the same name to the Matfile, since
    //this would be followed with an memory leak error, when the object MatfileIO wasn't closed before.
    concepts::Set<std::string> matvar_str_cur_;
 
    //flag that controls if one wants to overwrite variables or forbid to do so
    //it can be controlled with the overWrite(bool) routine
    bool overWrite_;
 
    std::string matfileEnding_(const std::string& filename);
 
    //##################################################################
    //              add section for sparse objects
    //##################################################################
 
    template<class T>
    void add_(const SparseMatrix<T>& sparseM, const std::string& varName,
              enum matio_compression compress);
 
    template<class T>
    void add_(const DiagonalMatrix<T>& diagM, const std::string& varName,
              enum matio_compression compress);
 
    //##################################################################
    //              add section for dense objects
    //##################################################################
 
    template<class T>
    void add_(const ElementMatrix<T>& dense, const std::string& varName,
              enum matio_compression compress);
 
    template<uint dim>
    void add_(const Array<Point<Real,dim> >& array, const std::string& varName,
              enum matio_compression compress);
 
    template<uint dim>
    void add_(const Array<Point<Cmplx,dim> >& array, const std::string& varName,
              enum matio_compression compress);
 
    template<class T>
    void add_(const Array<T>& array, const std::string& varName,
              enum matio_compression compress);
 
    template<class T>
    void add_(const Vector<T>& vec, const std::string& varName,
              enum matio_compression compress);
 
    template<class T>
    void add_(const std::vector<T> &vec, const std::string& varName,
              enum matio_compression compress);
 
    template<uint dim>
    void add_(const Mapping<Real, dim>& map, const std::string& varName,
              enum matio_compression compress);
 
    template<uint dim>
    void add_(const Mapping<Cmplx, dim>& map, const std::string& varName,
              enum matio_compression compress);
 
    template<uint dim>
    void add_(const Point<Real, dim>& point, const std::string& varName,
              enum matio_compression compress);
 
    template<uint dim>
    void add_(const Point<Cmplx, dim>& point, const std::string& varName,
              enum matio_compression compress);
 
    void add_(const Real& scalar, const std::string& varName,
              enum matio_compression compress);
 
    void add_(const Cmplx& scalar, const std::string& varName,
              enum matio_compression compress);
 
    void add_(const int scalar, const std::string& str,
              enum matio_compression compress);
 
    void add_(const uint scalar, const std::string& str,
              enum matio_compression compress);
 
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //TODO:     add section for cell objects ?!
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // possible further add classes
    // void add_ vector<Vector>
    // void add_ std::vector<ElementMatrix>
    // void add_ std::vector<SparseMatrix>
 
 
    //##################################################################
    //              getter section for sparse objects
    //##################################################################
 
    template<class T>
    void get_(SparseMatrix<T>& sparse, matvar_t*& matvar);
 
    template<class T>
    void get_(DiagonalMatrix<T>& sparse, matvar_t*& matvar);
 
    //##################################################################
    //              getter section for dense objects
    //##################################################################
 
 
    template<class T>
    void get_(ElementMatrix<T>& dense, matvar_t*& matvar);
 
    template<class T>
    void get_(DenseMatrix<T>& dense, matvar_t*& matvar);
 
    template<class T>
    void get_(Array<T>& arr, matvar_t*& matvar);
 
    template<class T>
    void get_(Vector<T>& vec, matvar_t*& matvar);
 
    template<class T>
    void get_(std::vector<T>& seq, matvar_t*& matvar);
 
    template<class T>
    void get_(std::vector<Vector<T> >& seq, matvar_t*& matvar);
 
    template<uint dim>
    void get_(Mapping<Real, dim>& map, matvar_t*& matvar);
 
    template<uint dim>
    void get_(Mapping<Cmplx, dim>& map, matvar_t*& matvar);
 
    template<uint dim>
    void get_(Point<Real, dim>& point, matvar_t*& matvar);
 
    template<uint dim>
    void get_(Point<Cmplx, dim>& point, matvar_t*& matvar);
 
    void get_(Real& scalar, matvar_t*& matvar);
 
    void get_(Cmplx& scalar, matvar_t*& matvar);
 
    void get_(int& scalar, matvar_t*& matvar) throw (MatfileIOError);
 
    void get_(uint& scalar, matvar_t*& matvar) throw (MatfileIOError);
 
    //#################################################################
    //                matvar create section
    //#################################################################
 
    void createDenseReal_(uint m, uint n, const std::string& varName,
                          Real*& dataAccP);
 
    void createDenseCmplx_(uint m, uint n, const std::string& varName,
                           Real*& realP, Real*& imgP);
 
 
    //#################################################################
    //              private control section
    //#################################################################
 
    inline bool isReal_(matvar_t* var) const {
      return (var->isComplex == 0);
    }
    inline bool isCmplx_(matvar_t* var) const {
      return (var->isComplex != 0);
    }
 
    inline bool isSparse_(matvar_t* var) const {
      return (var->class_type == MAT_C_SPARSE);
    }
 
    inline bool isDense_(matvar_t* var) const {
      return (var->class_type == MAT_C_DOUBLE);
    }
 
    bool isInt_(matvar_t* var) const{
      enum matio_classes vc = var->class_type;
      return (vc == MAT_C_INT8 || vc == MAT_C_INT16 ||
              vc == MAT_C_INT32|| vc == MAT_C_INT64);
    }
 
    bool isUint_(matvar_t* var) const{
      enum matio_classes vc = var->class_type;
      return (vc == MAT_C_UINT8 || vc == MAT_C_UINT16 ||
              vc == MAT_C_UINT32|| vc == MAT_C_UINT64);
    }
 
    bool isVector_(matvar_t* var) const;
 
    bool hasDiagStructur_(matvar_t* var) const;
 
    inline bool isQuadratic_(matvar_t* var) const {
      return (var->dims[0] == var->dims[1]) && (var->rank == 2);
    }
 
    bool isScalar_(matvar_t* var) const;
 
    uint lengthVector_(matvar_t* var) const;
 
    //#################################################################
    //              private assert section
    //#################################################################
    // These methods are used to work with current pointers and don't reread the file, like in
    // possible public analog methods having a string as input, if assert, they free the matvar_t.
 
 
    void wrongField_(matvar_t*& var) const throw();
 
    void wrongStructure_(matvar_t*& var) const throw();
 
    void assertDimension_(uint dim, uint vardim) const throw (MatfileIOError);
 
    void assertQuadratic_(matvar_t*& var) const throw (MatfileIOError);
 
    void assertVector_(matvar_t*& var) const throw (MatfileIOError);
 
    void assertDiagStructur_(matvar_t*& var) const throw (MatfileIOError);
 
    void assertScalar_(matvar_t*& var) const throw (MatfileIOError);
 
    void assertVar_(matvar_t* var) const throw (MatfileIOError);
 
    void assertVar_(mat_sparse_t* var) const throw (MatfileIOError);
 
    void assertOpenFile_(mat_t* file) const throw (MatfileIOError);
 
  };
 
}
#endif