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/MatrixParam.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 MatrixParam<Type>
   {
      
   public:
  
      DMatrixParam(const char *label, DMatrix<Type>& matrix, int m, int n, 
                   bool isRequired = true);
 
      void writeParam(std::ostream &out) const;
 
      using ParamComponent::indent;
      using Parameter::isActive;
      using MatrixParam<Type>::m;
      using MatrixParam<Type>::n;
 
   protected:
      
      using MatrixParam<Type>::hasBrackets;
 
      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_;
   
   };
 
   /*
   * DMatrix constructor.
   */
   template <class Type>
   DMatrixParam<Type>::DMatrixParam(const char* label, DMatrix<Type>& matrix, 
                                    int m, int n, bool isRequired)
    : MatrixParam<Type>(label, m, n, isRequired),
      matrixPtr_(&matrix)
   {
      // Set delimiter strings to left and right square brackets.
      MatrixParam<Type>::setBrackets("[","]");
   }
 
   /*
   * 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);
         }
      }
 
      MatrixParam<Type>::readEndBracket(in);
   }
 
   /*
   * 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) const
   {
      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()");
         }
  
         if (hasBrackets()) {
            out << indent() << Parameter::label_ << std::endl;
         } 
         Label space("");
         int i, j;
         for (i = 0; i < m(); ++i) {
            if (i == 0 && !hasBrackets()) {
               out << indent() << Parameter::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;
         }
         MatrixParam<Type>::writeEndBracket(out);
      }
   }
 
} 
#endif