DMatrixParam.h

#ifndef UTIL_DMATRIX_PARAM_H
#define UTIL_DMATRIX_PARAM_H

/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/param/Parameter.h>
#include <util/containers/DMatrix.h>
#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#endif
#include <util/global.h>

#include <iomanip> 

namespace Util
{

   template <class Type>
   class DMatrixParam : public Parameter
   {
      
   public:
  
      DMatrixParam(const char *label, DMatrix<Type>& matrix, int m, int n, bool isRequired = true);
 
      void writeParam(std::ostream &out);

   protected:
      
      virtual void readValue(std::istream& in);

      virtual void loadValue(Serializable::IArchive& ar);

      virtual void saveValue(Serializable::OArchive& ar);

      #ifdef UTIL_MPI

      virtual void bcastValue();
      #endif

   private:
   
      DMatrix<Type>* matrixPtr_;
   
      int m_; 

      int n_; 
   
   };

   /*
   * DMatrix constructor.
   */
   template <class Type>
   DMatrixParam<Type>::DMatrixParam(const char* label, DMatrix<Type>& matrix, int m, int n, bool isRequired)
    : Parameter(label, isRequired),
      matrixPtr_(&matrix),
      m_(m),
      n_(n)
   {}

   /*
   * Read a DMatrix from isteam.
   */
   template <class Type>
   void DMatrixParam<Type>::readValue(std::istream &in)
   {  
      // Preconditions
      if (!(matrixPtr_->isAllocated())) {
         UTIL_THROW("Cannot read unallocated DMatrix");
      }
      if (m_ != matrixPtr_->capacity1()) {
         UTIL_THROW("Error: Logical size m_ != DMatrix<Type>::capacity1()");
      }
      if (n_ != matrixPtr_->capacity2()) {
         UTIL_THROW("Error: Logical size n_ != DMatrix<Type>::capacity2()");
      }

      int i, j;
      for (i = 0; i < m_; ++i) {
         for (j = 0; j < n_; ++j) {
            in >> (*matrixPtr_)(i, j);
         }
      }
   }

   /*
   * Load a DMatrix from input archive.
   */
   template <class Type>
   void DMatrixParam<Type>::loadValue(Serializable::IArchive& ar)
   {  
      if (!(matrixPtr_->isAllocated())) {
         matrixPtr_->allocate(m_, n_);
      } else {
         if (m_ != matrixPtr_->capacity1()) {
            UTIL_THROW("Error: Logical size m_ != DMatrix<Type>::capacity1()");
         }
         if (n_ != matrixPtr_->capacity2()) {
            UTIL_THROW("Error: Logical size n_ != DMatrix<Type>::capacity2()");
         }
      }
      ar >> *matrixPtr_;
   }

   /*
   * Save a DMatrix to an output archive.
   */
   template <class Type>
   void DMatrixParam<Type>::saveValue(Serializable::OArchive& ar)
   {
      if (m_ != matrixPtr_->capacity1()) {
         UTIL_THROW("Error: Logical size m_ != DMatrix<Type>::capacity1()");
      }
      if (n_ != matrixPtr_->capacity2()) {
         UTIL_THROW("Error: Logical size n_ != DMatrix<Type>::capacity2()");
      }
      ar << *matrixPtr_; 
   }

   #ifdef UTIL_MPI
   /*
   * Broadcast a DMatrix.
   */
   template <class Type>
   void DMatrixParam<Type>::bcastValue()
   {  
      if (!(matrixPtr_->isAllocated())) {
         matrixPtr_->allocate(m_, n_);
      } else {
         if (m_ != matrixPtr_->capacity1()) {
            UTIL_THROW("Error: Logical size m_ > DMatrix<Type>::capacity1()");
         }
         if (n_ != matrixPtr_->capacity2()) {
            UTIL_THROW("Error: Logical size n_ > DMatrix<Type>::capacity2()");
         }
      }
      bcast<Type>(ioCommunicator(), *matrixPtr_, m_, n_, 0); 
   }
   #endif

   /*
   * Write a DMatrixParam.
   */
   template <class Type>
   void DMatrixParam<Type>::writeParam(std::ostream &out)
   {
      if (isActive()) {
         // Preconditions
         if (!(matrixPtr_->isAllocated())) {
            UTIL_THROW("Cannot read unallocated DMatrix");
         }
         if (m_ > matrixPtr_->capacity1()) {
            UTIL_THROW("Error: Logical size m_ > DMatrix<Type>::capacity1()");
         }
         if (n_ > matrixPtr_->capacity2()) {
            UTIL_THROW("Error: Logical size n_ > DMatrix<Type>::capacity2()");
         }
   
         Label space("");
         int i, j;
         for (i = 0; i < m_; ++i) {
            if (i == 0) {
               out << indent() << label_;
            } else {
               out << indent() << space;
            }
            for (j = 0; j < n_; ++j) {
               out << std::right << std::scientific 
                   << std::setprecision(Parameter::Precision) 
                   << std::setw(Parameter::Width)
                   << (*matrixPtr_)(i, j);
            }
            out << std::endl;
         }
      }
   }

} 
#endif