CArray2DParam.h

#ifndef UTIL_CARRAY_2D_PARAM_H
#define UTIL_CARRAY_2D_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/global.h>
 
#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#endif
 
#include <iomanip> 
 
namespace Util
{
 
   template <class Type>
   class CArray2DParam : public MatrixParam<Type>
   {
      
   public:
  
      CArray2DParam(const char *label, Type* ptr, 
                    int m, int n, int np, 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:
   
      Type* ptr_;
   
      int np_; 
   
   };
 
 
   /*
   * CArray2D constructor.
   */
   template <class Type>
   CArray2DParam<Type>::CArray2DParam(const char* label, Type* ptr, 
                                      int m, int n, int np, 
                                      bool isRequired)
    : MatrixParam<Type>(label, m, n, isRequired),
      ptr_(ptr),
      np_(np)
   {
      // Set matrix delimiter symbols to left and right square brackets
      MatrixParam<Type>::setBrackets("[","]");
   }
 
   /*
   * Read a DArray from isteam.
   */
   template <class Type>
   void CArray2DParam<Type>::readValue(std::istream &in)
   {  
      int i, j;
      for (i = 0; i < m(); ++i) {
         for (j = 0; j < n(); ++j) {
            in >> ptr_[i*np_ + j];
         }
      }
      MatrixParam<Type>::readEndBracket(in);
   }
 
   /*
   * Load a DArray from input archive.
   */
   template <class Type>
   void CArray2DParam<Type>::loadValue(Serializable::IArchive& ar)
   {  ar.unpack(ptr_, m(), n(), np_); }
 
   /*
   *  Save a DArray to an output archive.
   */
   template <class Type>
   void CArray2DParam<Type>::saveValue(Serializable::OArchive& ar)
   {  ar.pack(ptr_, m(), n(), np_); }
 
   #ifdef UTIL_MPI
   /*
   * Broadcast a DArray.
   */
   template <class Type>
   void CArray2DParam<Type>::bcastValue()
   {  bcast<Type>(ioCommunicator(), ptr_, m()*np_, 0); }
   #endif
 
   /*
   * Write a CArray2DParam.
   */
   template <class Type>
   void CArray2DParam<Type>::writeParam(std::ostream &out) const
   {
 
      if (isActive()) {
         Label space("");
         int i, j;
  
         if (hasBrackets()) {
            out << indent() << Parameter::label_ << std::endl;
         } 
         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)
                   << ptr_[i*np_ + j];
            }
            out << std::endl;
         }
         MatrixParam<Type>::writeEndBracket(out);
      }
   }
} 
#endif