Domain.h

#ifndef DDMD_DOMAIN_H
#define DDMD_DOMAIN_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 <simp/boundary/Boundary.h>     // typedef used in interface
#include <util/param/ParamComposite.h>  // base class
#include <util/containers/FMatrix.h>    // member template
#include <util/containers/FArray.h>     // member template
#include <util/space/IntVector.h>       // member
#include <util/space/Grid.h>            // member
#include <util/space/Dimension.h>       // constant expression
#include <util/global.h>

namespace DdMd
{

   using namespace Util;
   using namespace Simp;

   class Domain : public ParamComposite
   {

   public:

      Domain();

      virtual ~Domain();

      // Mutators

      #if UTIL_MPI

      void setGridCommunicator(MPI::Intracomm& communicator);

      #else

      void setRank(int Rank);

      #endif

      void setBoundary(Boundary& boundary);

      virtual void readParameters(std::istream& in);

      virtual void loadParameters(Serializable::IArchive &ar);

      virtual void save(Serializable::OArchive &ar);
  
      // Accessors

      const Grid& grid() const;

      int gridCoordinate(int i) const;

      int gridDimension(int i) const;

      bool gridIsPeriodic(int i) const;

      int gridRank() const;

      bool isMaster() const;

      int sourceRank(int i, int j) const;

      int destRank(int i, int j) const;

      int shift(int i, int j) const;

      #if UTIL_MPI

      MPI::Intracomm& communicator() const;
      #endif

      double domainBound(int i, int j) const;

      int ownerRank(const Vector& position) const;

      bool isInDomain(const Vector& position) const;

      bool isInitialized() const;

      bool hasBoundary() const;

   private:

      // Ranks of sending (source) processor for each shift.
      FMatrix<int, Dimension, 2>  sourceRanks_;

      // Ranks of receiving (destination) processor for each shift.
      FMatrix<int, Dimension, 2>  destRanks_;

      // Shifts due to periodic boundary conditions in each send direction.
      FMatrix<int, Dimension, 2>  shift_;

      // Grid object with dimensions given by gridDimensions_.
      Grid grid_;

      // Number of processors in each direction.
      IntVector gridDimensions_;

      // Coordinates of this domain in processor grid.
      IntVector gridCoordinates_;

      // Rank of this processor in Cartesian communicator.
      int gridRank_;

      // Is each direction periodic (1 = true, 0 = false).
      FArray<bool, Dimension> gridIsPeriodic_;

      #if UTIL_MPI

      // Pointer to Intracommunicator.
      MPI::Intracomm* intracommPtr_;

      #endif

      // Pointer to associated Boundary object.
      Boundary* boundaryPtr_;

      // Is this object initialized (Has a grid been set?)
      bool isInitialized_;

      /*
      * Initialize after reading/loading gridDimensions.
      *
      * Used in implementation of readParameters and loadParameters.
      */
      void initialize();

   };

   #if UTIL_MPI

   inline MPI::Intracomm& Domain::communicator() const
   {
      assert(intracommPtr_);
      return *intracommPtr_; 
   }

   #endif

   /*
   * Return processor Grid by const reference.
   */
   inline const Grid& Domain::grid() const
   {  
      assert(isInitialized_);
      return grid_; 
   }

   /*
   * Return a coordinate of this processor within grid.
   */
   inline int Domain::gridCoordinate(int i) const
   {  
      assert(isInitialized_);
      return gridCoordinates_[i]; 
   }

   inline int Domain::gridDimension(int i) const
   {  
      assert(isInitialized_);
      return gridDimensions_[i]; 
   }

   inline bool Domain::gridIsPeriodic(int i) const
   {  
      assert(isInitialized_);
      return gridIsPeriodic_[i]; 
   }

   /*
   * Rank of this processor in Cartesian communicator.
   */
   inline int Domain::gridRank() const
   {  
      assert(isInitialized_);
      return gridRank_; 
   }

   /*
   * Is this the master processor (gridRank == 0)?
   */
   inline bool Domain::isMaster() const
   {  
      assert(isInitialized_);
      return bool(gridRank_ == 0); 
   }

   /*
   * Rank of the processor from which to receive in transfer (i, j).
   */
   inline int Domain::sourceRank(int i, int j) const
   {  
      assert(isInitialized_);
      return sourceRanks_(i, j); 
   }

   /*
   * Rank of the processor to which to send in transfer (i, j).
   */
   inline int Domain::destRank(int i, int j) const
   {  
      assert(isInitialized_);
      return destRanks_(i,j); 
   }

   /*
   * Shift applied in direction i for transfer (i, j)
   */
   inline int Domain::shift(int i, int j) const
   {  
      assert(isInitialized_);
      return shift_(i, j);  
   }

   /*
   * Has this Domain been initialized by calling readParam?
   */
   inline bool Domain::isInitialized() const
   {  return isInitialized_;  }

   /*
   * Has an associated Boundary been set ?
   */
   inline bool Domain::hasBoundary() const
   {  return (boundaryPtr_ != 0);  }

}
#endif