ddMd/storage/GroupStorage.h

#ifndef DDMD_GROUP_STORAGE_H
#define DDMD_GROUP_STORAGE_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 <util/global.h>
#include <util/param/ParamComposite.h>   // base class
#include <ddMd/storage/GroupExchanger.h> // base class
#include <ddMd/communicate/GroupDistributor.h>   // member
#include <ddMd/communicate/GroupCollector.h>     // member
#include <ddMd/chemistry/Atom.h>         // member template parameter
#include <ddMd/chemistry/Group.h>        // member template parameter
#include <util/space/IntVector.h>        // member template parameter
#include <util/containers/DArray.h>      // member template
#include <util/containers/GPArray.h>     // member template
#include <util/containers/FMatrix.h>     // member template
#include <util/containers/ArraySet.h>    // member template
#include <util/containers/ArrayStack.h>  // member template

#include "GroupIterator.h"               // inline functions
#include "ConstGroupIterator.h"          // inline functions

namespace DdMd
{

   class Domain;
   class Buffer;
   class AtomStorage;
   using namespace Util;

   template <int N>
   class GroupStorage : public ParamComposite, public GroupExchanger
   {

   public:

      GroupStorage();

      ~GroupStorage();


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

      void initialize(int capacity, int totalCapacity);

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

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

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


      Group<N>* newPtr();

      void add();

      Group<N>* add(int id); 

      void returnPtr();

      void remove(Group<N>* groupPtr); 

      void clearGroups(); 

      int size() const;

      int capacity() const;


 
      void begin(GroupIterator<N>& iterator);
 
      void begin(ConstGroupIterator<N>& iterator) const;

      Group<N>* find(int id) const;



      int totalCapacity() const;

      #ifdef UTIL_MPI
      void computeNTotal(MPI::Intracomm& communicator);
      #else
      void computeNTotal();
      #endif
   
      int nTotal() const;

      void unsetNTotal();


      
      virtual
      void markSpanningGroups(FMatrix<double, Dimension, 2>& bound, 
                              FMatrix<double, Dimension, 2>& inner, 
                              FMatrix<double, Dimension, 2>& outer, 
                              IntVector& gridFlags);
   
      #ifdef UTIL_MPI

      virtual
      void pack(int i, int j, Buffer& buffer);
   
      virtual
      void unpack(Buffer& buffer, AtomStorage& atomStorage);
      #endif // endif ifdef UTIL_MPI
   
      virtual
      void markGhosts(AtomStorage& atomStorage, 
                      FMatrix<GPArray<Atom>, Dimension, 2>&  sendArray,
                      IntVector& gridFlags);
   
      virtual
      void findGhosts(AtomStorage& atomStorage);
   
      #ifdef UTIL_MPI
      virtual
      bool isValid(AtomStorage& atomStorage, MPI::Intracomm& communicator, 
                   bool hasGhosts);
      #else
      virtual
      bool isValid(AtomStorage& atomStorage, bool hasGhosts);
      #endif


 
      #ifdef UTIL_MPI
      virtual void computeStatistics(MPI::Intracomm& communicator);
      #else
      virtual void computeStatistics();
      #endif

      void clearStatistics();

      void outputStatistics(std::ostream& out);

      int maxNGroup() const;



      GroupDistributor<N>& distributor();

      GroupCollector<N>& collector();

      bool isValid();


   private:

      // Memory pool that holds all available group objects.
      DArray< Group<N> > groups_;

      // Set of pointers to local groups.
      ArraySet< Group<N> > groupSet_;

      // Stack of pointers to unused local Group objects.
      ArrayStack< Group<N> > reservoir_;

      // Array of pointers to groups, indexed by global group Id.
      // Elements corresponding to absent groups hold null pointers.
      DArray< Group<N>* > groupPtrs_;

      // Array identifying empty groups, marked for later removal 
      GPArray< Group<N> > emptyGroups_;

      // Pointer to space for a new local Group
      Group<N>* newPtr_;

      // Capacity for local groups on this processor.
      int capacity_;

      // Maximum number of groups on all processors, maximum id + 1
      int totalCapacity_;

      int maxNGroupLocal_;     
   
      Setable<int> maxNGroup_;     
      
      // Total number of distinct groups on all processors.
      Setable<int> nTotal_;

      // Distributor and Collector objects
      GroupDistributor<N> distributor_;
      GroupCollector<N> collector_;

      /*
      * Allocate and initialize all private containers.
      */
      void allocate();
    
   };

   // Inline member function definitions

   template <int N>
   inline int GroupStorage<N>::size() const
   {  return groupSet_.size(); }

   template <int N>
   inline int GroupStorage<N>::capacity() const
   {  return capacity_; }

   template <int N>
   inline int GroupStorage<N>::totalCapacity() const
   {  return totalCapacity_; }

   template <int N>
   inline int GroupStorage<N>::nTotal() const
   {  return nTotal_.value(); }

   /*
   * Return pointer to Group with specified id.
   */
   template <int N>
   inline Group<N>* GroupStorage<N>::find(int id) const
   {  return groupPtrs_[id]; }

   /*
   * Set iterator to beginning of the set of local groups.
   */
   template <int N>
   inline void GroupStorage<N>::begin(GroupIterator<N>& iterator)
   {  groupSet_.begin(iterator); }
 
   /*
   * Set const iterator to beginning of the set of local groups.
   */
   template <int N>
   inline 
   void GroupStorage<N>::begin(ConstGroupIterator<N>& iterator) const
   {  groupSet_.begin(iterator); }

   template <int N>
   inline GroupDistributor<N>& GroupStorage<N>::distributor()
   {  return distributor_; }

   template <int N>
   inline GroupCollector<N>& GroupStorage<N>::collector()
   {  return collector_; }

} 
#endif