FArrayParam.h

#ifndef UTIL_F_ARRAY_PARAM_H
#define UTIL_F_ARRAY_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/FArray.h>
#include <util/global.h>

#include <iomanip> 

namespace Util
{

   template <class Type, int N>
   class FArrayParam : public Parameter
   {
   
   public:

      FArrayParam(const char *label, FArray<Type, N>& array, 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:
   
      FArray<Type, N>* arrayPtr_;
   
   };

   /*
   * FArrayParam<Type, N> constructor.
   */
   template <class Type, int N>
   FArrayParam<Type, N>::FArrayParam(const char *label, FArray<Type, N>& array, bool isRequired)
    : Parameter(label, isRequired),
      arrayPtr_(&array)
   {}

   /*
   * Read a FArray from isteam.
   */
   template <class Type, int N>
   void FArrayParam<Type, N>::readValue(std::istream &in)
   {  
      for (int i = 0; i < N; ++i) {
         in >> (*arrayPtr_)[i];
      }
   }

   /*
   * Load a FArray from input archive.
   */
   template <class Type, int N>
   void FArrayParam<Type, N>::loadValue(Serializable::IArchive& ar)
   {  ar >> *arrayPtr_; }  

   /*
   * Save a FArray to an output archive.
   */
   template <class Type, int N>
   void FArrayParam<Type, N>::saveValue(Serializable::OArchive& ar)
   { ar << *arrayPtr_; }

   #ifdef UTIL_MPI
   /*
   * Broadcast a FArray.
   */
   template <class Type, int N>
   void FArrayParam<Type, N>::bcastValue()
   {  bcast<Type>(ioCommunicator(), &((*arrayPtr_)[0]), N, 0); }
   #endif

   /*
   * Write a FArray parameter.
   */
   template <class Type, int N>
   void FArrayParam<Type, N>::writeParam(std::ostream &out) 
   {
      if (isActive()) {
         Label space("");
         for (int i = 0; i < N; ++i) {
            if (i == 0) {
               out << indent() << label_;
            } else {
               out << indent() << space;
            }
            out << std::right << std::scientific 
                << std::setprecision(Parameter::Precision) 
                << std::setw(Parameter::Width)
                << (*arrayPtr_)[i] 
                << std::endl;
         }
      }
   }

} 
#endif