Exchanger.h

#ifndef DDMD_EXCHANGER_H
#define DDMD_EXCHANGER_H

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <ddMd/misc/DdTimer.h>
#include <util/space/IntVector.h>
#include <simp/boundary/Boundary.h>
#include <util/containers/FMatrix.h>
#include <util/containers/GPArray.h>


namespace DdMd
{

   class Domain;
   class Atom;
   class AtomStorage;
   class Buffer;
   class GroupExchanger;

   using namespace Util;
   using namespace Simp;

   class Exchanger
   {

   public:

      Exchanger();

      ~Exchanger();

      void associate(const Domain& domain, const Boundary& boundary, 
                     AtomStorage& atomStorage, Buffer& buffer);

      void addGroupExchanger(GroupExchanger& groupExchanger);

      void allocate();

      void setPairCutoff(double pairCutoff);

      void exchange();

      void update();

      void reverseUpdate();

      void outputStatistics(std::ostream& out, double time, int nStep);

      DdTimer& timer();

      enum timeId {START, ATOM_PLAN, INIT_GROUP_PLAN, CLEAR_GHOSTS,
                   PACK_ATOMS, PACK_GROUPS, REMOVE_ATOMS, 
                   SEND_RECV_ATOMS, UNPACK_ATOMS, UNPACK_GROUPS, 
                   MARK_GROUP_GHOSTS, INIT_SEND_ARRAYS, PACK_GHOSTS, 
                   SEND_RECV_GHOSTS, UNPACK_GHOSTS, FIND_GROUP_GHOSTS, 
                   PACK_UPDATE, SEND_RECV_UPDATE, UNPACK_UPDATE, 
                   LOCAL_UPDATE, PACK_FORCE, SEND_RECV_FORCE, 
                   UNPACK_FORCE, LOCAL_FORCE, NTime};

   private:

      FMatrix< GPArray<Atom>, Dimension, 2>  sendArray_;

      FMatrix< GPArray<Atom>, Dimension, 2>  recvArray_;

      #ifdef UTIL_MPI

      GPArray<Atom> sentAtoms_;
      #endif // UTIL_MPI

      FMatrix< double, Dimension, 2>  bound_;

      FMatrix< double, Dimension, 2>  inner_;

      FMatrix< double, Dimension, 2>  outer_;

      IntVector gridFlags_;

      const Boundary*  boundaryPtr_;

      const Domain*  domainPtr_;

      AtomStorage* atomStoragePtr_;

      GPArray<GroupExchanger> groupExchangers_;

      Buffer*  bufferPtr_;

      double pairCutoff_;

      DdTimer timer_;

      void exchangeAtoms();

      void exchangeGhosts();

      void stamp(unsigned int timeId);

   };

   // Inline methods.

   // Return internal timer by reference (public).
   inline DdTimer& Exchanger::timer()
   {  return timer_; }

   // Stamp internal timer (private)
   inline void Exchanger::stamp(unsigned int timeId) 
   {  timer_.stamp(timeId); }

}
#endif