ddMd/storage/AtomStorage.h

#ifndef DDMD_ATOM_STORAGE_H
#define DDMD_ATOM_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/param/ParamComposite.h>        // base class

#include <ddMd/chemistry/AtomArray.h>         // member
#include <ddMd/storage/AtomMap.h>             // member
#include <ddMd/communicate/AtomDistributor.h> // member
#include <ddMd/communicate/AtomCollector.h>   // member
#include <ddMd/chemistry/Atom.h>              // member template argument
#include <ddMd/chemistry/Group.h>             // in function templates
#include <simp/boundary/Boundary.h>           // typedef
#include <util/containers/DArray.h>           // member template
#include <util/containers/ArraySet.h>         // member template
#include <util/containers/ArrayStack.h>       // member template
#include <util/misc/Setable.h>                // member template
#include <util/global.h>

class AtomStorageTest;

namespace DdMd
{

   class AtomIterator;
   class ConstAtomIterator;
   class GhostIterator;
   class ConstGhostIterator;

   using namespace Util;
   using namespace Simp;

   class AtomStorage : public ParamComposite
   {

   public:

      AtomStorage();

      ~AtomStorage();

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

      void initialize(int atomCapacity, int ghostCapacity,
                      int totalAtomCapacity);

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

      void zeroForces(bool zeroGhosts);
  


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

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



      Atom* newAtomPtr(); 

      void addNewAtom(); 

      Atom* addAtom(int id); 

      void removeAtom(Atom* atomPtr); 

      void clearAtoms(); 

      int nAtom() const;

      int atomCapacity() const;



      Atom* newGhostPtr(); 

      void addNewGhost(); 

      Atom* addGhost(int id); 

      void removeGhost(Atom* atomPtr); 

      void clearGhosts(); 

      int nGhost() const;

      int ghostCapacity() const;



      void transformCartToGen(const Boundary& boundary);
 
      void transformGenToCart(const Boundary& boundary);

      bool isCartesian() const;



      void makeSnapshot();

      void clearSnapshot();

      double maxSqDisplacement();



      void begin(AtomIterator& iterator);
 
      void begin(ConstAtomIterator& iterator) const;
 
      void begin(GhostIterator& iterator);

      void begin(ConstGhostIterator& iterator) const;


     
      int totalAtomCapacity() const;

      #ifdef UTIL_MPI

      void computeNAtomTotal(MPI::Intracomm& communicator);
      #endif

      int nAtomTotal() const;

      void unsetNAtomTotal();


     
      const AtomMap& map() const;

      #ifdef UTIL_MPI

      AtomDistributor& distributor();

      AtomCollector& collector();
      #endif
   


      bool isInitialized() const;

      bool isValid() const;

      #ifdef UTIL_MPI

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


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

      void clearStatistics();

      void outputStatistics(std::ostream& out);

      int maxNAtom() const;

      int maxNGhost() const;


   private:

      // Array that holds all available local Atom objects.
      AtomArray  atoms_;

      // Set of pointers to local atoms.
      ArraySet<Atom>  atomSet_;

      // Stack of pointers to unused local Atom objects.
      ArrayStack<Atom>  atomReservoir_;

      // Array that holds all available ghost Atom objects.
      AtomArray  ghosts_;

      // Set of pointers to ghost atoms.
      ArraySet<Atom>  ghostSet_;

      // Stack of pointers to unused ghost Atom objects.
      ArrayStack<Atom>  ghostReservoir_;

      // Map of atomIds to atom pointers.
      AtomMap  map_;

      // Array of stored old positions.
      DArray<Vector>  snapshot_;

      // Pointer to space for a new local Atom
      Atom*  newAtomPtr_;

      // Pointer to space for a new ghost Atom.
      Atom*  newGhostPtr_;

      // Capacity for local atoms on this processor.
      int  atomCapacity_;

      // Capacity for ghost atoms on this processors.
      int  ghostCapacity_;

      // Maximum number of atoms on all processors, maximum id + 1
      int  totalAtomCapacity_;

      int  maxNAtomLocal_; 
   
      int  maxNGhostLocal_;

      #ifdef UTIL_MPI
      // Total number of local atoms on all processors.
      Setable<int>  nAtomTotal_;

      Setable<int>  maxNAtom_;     

      Setable<int>  maxNGhost_;     

      // Distributor and collector
      AtomDistributor distributor_;
      AtomCollector collector_;
      #endif

      // Is addition or removal of atoms forbidden?
      bool locked_;

      // Is this object initialized (has memory been allocated?).
      bool isInitialized_;

      // Are atomic coordinates Cartesian (true) or generalized (false)?
      bool isCartesian_;

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

      friend class ::AtomStorageTest;
    
   };

   // Inline member function definitions

   inline int AtomStorage::nAtom() const
   { return atomSet_.size(); }

   inline int AtomStorage::nGhost() const
   { return ghostSet_.size(); }

   #ifdef UTIL_MPI
   inline AtomDistributor& AtomStorage::distributor()
   {  return distributor_; }

   inline AtomCollector& AtomStorage::collector()
   {  return collector_; }
   #endif

   inline int AtomStorage::atomCapacity() const
   { return atomCapacity_; }

   inline int AtomStorage::ghostCapacity() const
   { return ghostCapacity_; }

   inline int AtomStorage::totalAtomCapacity() const
   { return totalAtomCapacity_; }

   inline bool AtomStorage::isCartesian() const
   { return isCartesian_; }

   inline const AtomMap& AtomStorage::map() const
   { return map_; }

   /*
   * On master processor (rank=0), stored value of total number of atoms.
   */
   inline int AtomStorage::nAtomTotal() const
   {
      #ifdef UTIL_MPI
      return nAtomTotal_.value();
      #else
      return atomSet_.size();
      #endif
   }

}
#endif