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/Parameter.h>
#include <util/global.h>

#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#endif

#include <iomanip> 

namespace Util
{

   template <class Type>
   class CArray2DParam : public Parameter
   {
      
   public:
  
      CArray2DParam(const char *label, Type* ptr, 
                    int m, int n, int np, 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:
   
      Type* ptr_;
   
      int m_; 

      int n_; 

      int np_; 
   
   };


   /*
   * CArray2D constructor.
   */
   template <class Type>
   CArray2DParam<Type>::CArray2DParam(const char* label, Type* ptr, int m, int n, int np, bool isRequired)
    : Parameter(label, isRequired),
      ptr_(ptr),
      m_(m),
      n_(n),
      np_(np)
   {}

   /*
   * 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];
         }
      }
   }

   /*
   * 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)
   {
      if (isActive()) {
         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)
                   << ptr_[i*np_ + j];
            }
            out << std::endl;
         }
      }
   }
} 
#endif