MpiLoader.h

#ifndef UTIL_MPI_LOADER_H
#define UTIL_MPI_LOADER_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/containers/DArray.h>   // template argument
#include <util/containers/FArray.h>   // template argument
#include <util/containers/DMatrix.h>  // template argument
#include <util/mpi/MpiFileIo.h>       // used in template implementation
#include <util/mpi/MpiTraits.h>       // used in template implementation
#include <util/mpi/MpiSendRecv.h>     // used in template implementation
#include <util/global.h>


namespace Util
{

   template <class IArchive>
   class MpiLoader 
   {

   public:

      MpiLoader(MpiFileIo& mpiFileIo, IArchive& archive);

      template <typename Data>
      void load(Data &value);
   
      template <typename Data>
      void load(Data *value, int n);
   
      template <typename Data>
      void load(DArray<Data>& array, int n);
   
      template <typename Data, int N>
      void load(FArray<Data, N >& array);
   
      template <typename Data> void 
      load(Data* value, int m, int n, int np);
  
      template <typename Data> 
      void load(DMatrix<Data>& matrix, int m, int n);

   private:

      // Pointer to associated MpiFileIo (passed to constructor).
      MpiFileIo*  mpiFileIoPtr_;

      // Pointer to associated input archive (passed to constructor).
      IArchive*  archivePtr_;
 
   };
 
   /*
   * Constructor
   */
   template <typename IArchive> 
   MpiLoader<IArchive>::MpiLoader(MpiFileIo& mpiFileIo, IArchive& archive)
    : mpiFileIoPtr_(&mpiFileIo),
      archivePtr_(&archive)
   {}

   /*  
   * Load and broadcast a single Data value.
   */
   template <typename IArchive> 
   template <typename Data> 
   void MpiLoader<IArchive>::load(Data &value)
   {
      if (mpiFileIoPtr_->isIoProcessor()) {
         *archivePtr_ >> value;
      }
      #ifdef UTIL_MPI
      if (mpiFileIoPtr_->hasIoCommunicator()) {
         bcast<Data>(mpiFileIoPtr_->ioCommunicator(), value, 0); 
      }
      #endif
   }
   
   /*  
   * Add a C array parameter, and load its elements.
   */
   template <typename IArchive> 
   template <typename Data>
   void MpiLoader<IArchive>::load(Data* value, int n)
   {
      if (mpiFileIoPtr_->isIoProcessor()) {
         for (int i = 0; i < n; ++i) {
            *archivePtr_ >> value[i];
         }
      }
      #ifdef UTIL_MPI
      if (mpiFileIoPtr_->hasIoCommunicator()) {
         bcast<Data>(mpiFileIoPtr_->ioCommunicator(), value, n, 0); 
      }
      #endif
   }

   /*
   * Load a DArray < Data > container.
   */
   template <typename IArchive> 
   template <typename Data>
   void 
   MpiLoader<IArchive>::load(DArray<Data>& array, int n)
   {
      if (mpiFileIoPtr_->isIoProcessor()) {
         *archivePtr_ >> array;
         if (array.capacity() < n) {
            UTIL_THROW("Error: DArray capacity < n");
         }
      }
      #ifdef UTIL_MPI
      if (mpiFileIoPtr_->hasIoCommunicator()) {
         bcast<Data>(mpiFileIoPtr_->ioCommunicator(), array, n, 0); 
      }
      #endif
   }

   /*
   * Load an FArray < Data, N > fixed-size 1D array container.
   */
   template <typename IArchive> 
   template <typename Data, int N>
   void MpiLoader<IArchive>::load(FArray<Data, N >& array)
   {
      if (mpiFileIoPtr_->isIoProcessor()) {
         for (int i = 0; i < N; ++i) {
            *archivePtr_ >> array[i];
         }
      }
      #ifdef UTIL_MPI
      if (mpiFileIoPtr_->hasIoCommunicator()) {
         bcast<Data>(mpiFileIoPtr_->ioCommunicator(), &(array[0]), N, 0); 
      }
      #endif
   }

   /*
   * Load a CArray2DParam < Data > C two-dimensional array parameter.
   */
   template <typename IArchive> 
   template <typename Data> 
   void 
   MpiLoader<IArchive>::load(Data *array, int m, int n, int np)
   {
      if (mpiFileIoPtr_->isIoProcessor()) {
         int i, j; 
         for (i = 0; i < m; ++i) {
            for (j = 0; j < n; ++j) {
               *archivePtr_ >> array[i*np + j];
            }
         }
      }
      #ifdef UTIL_MPI
      if (mpiFileIoPtr_->hasIoCommunicator()) {
         // Broadcast block of m rows of np elements each.
         bcast<Data>(mpiFileIoPtr_->ioCommunicator(), &(array[0]), m*np, 0); 
      }
      #endif
   }
  
   /*
   * Add and load a DMatrix < Data > C two-dimensional matrix parameter.
   */
   template <typename IArchive> 
   template <typename Data> 
   void MpiLoader<IArchive>::load(DMatrix<Data>& matrix, int m, int n)
   {
      if (mpiFileIoPtr_->isIoProcessor()) {
         *archivePtr_ >> matrix;
      }
      #ifdef UTIL_MPI
      if (mpiFileIoPtr_->hasIoCommunicator()) {
         bcast<Data>(mpiFileIoPtr_->ioCommunicator(), matrix, m, n, 0); 
      }
      #endif
   }
  
} 
#endif