AtomMap.h

#ifndef DDMD_ATOM_MAP_H
#define DDMD_ATOM_MAP_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/chemistry/Atom.h>     // member template argument
#include <util/containers/DArray.h>  // member template
#include <ddMd/chemistry/Group.h>    // member function template
#include <util/global.h>

#ifdef UTIL_CXX11
#include <unordered_map>
#else
#include <map>
#endif

namespace Util {
   template <typename T> class ArraySet;
}

namespace DdMd
{

   using namespace Util;

   class AtomMap 
   {

   public:

      AtomMap();

      ~AtomMap();

      void allocate(int totalAtomCapacity);

      void addLocal(Atom* ptr); 

      void removeLocal(Atom* ptr); 

      void addGhost(Atom* ptr);

      void removeGhost(Atom* ptr); 

      void clearGhosts(const ArraySet<Atom>& ghostSet);



      Atom* find(int atomId) const;  

      int nLocal() const;

      int nGhostDistinct() const;

      int nGhost() const;

      template <int N> 
      int findGroupLocalAtoms(Group<N>& group) const;

      template <int N> 
      int findGroupGhostAtoms(Group<N>& group) const;

      bool isValid() const;


   private:

      #ifdef UTIL_CXX11
      typedef std::unordered_multimap<int, Atom*> GhostMap;
      #else
      typedef std::multimap<int, Atom*> GhostMap;
      #endif

      // Array of pointers to atoms, indexed by Id.
      // Elements corresponding to absent atoms hold null pointers.
      DArray<Atom*> atomPtrs_;

      // Map for extra ghost images
      GhostMap ghostMap_;

      int nLocal_;

      int nGhostDistinct_;

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

      // Has this map been initialized (i.e., allocated)?
      bool isInitialized_;

      /*
      *  Design / invariants:
      *
      *  - If a local atom with id i is present, atomPtrs_[i]
      *    contains a pointer to that atom.
      *
      *  - If one or more ghosts with an atom id i are present,
      *    but there is no local atom with that id, atomPtrs_[i]
      *    contains a pointer to one such ghost.
      *
      *  - ghostMap_ contains pointers to all ghosts except those
      *    in atomPtrs_, stored using atom indices as keys. 
      *
      * One image of each physical atom, identified by id, is thus 
      * stored * in atomPtrs_, while ghostMap_ holds any "extra"
      * ghost images of atoms. If this processor does not contain
      * multiple images of any particle, ghostMap_ will be empty.
      */

   };

   // Inline function definitions

   /*
   * Return pointer to an Atom with specified id.
   */
   inline Atom* AtomMap::find(int atomId) const
   {  return atomPtrs_[atomId]; }

   /*
   * Return the number of local atoms.
   */ 
   inline int AtomMap::nLocal() const
   {  return nLocal_; }

   /*
   * Return the number of ghosts with distinct ids.
   */ 
   inline int AtomMap::nGhostDistinct() const
   { return nGhostDistinct_; }

   /*
   * Return the total number of ghosts, including images.
   */ 
   inline int AtomMap::nGhost() const
   { return nGhostDistinct_ + ghostMap_.size(); }

   // Function template definitions

   /*
   * Set pointers to all atoms in a Group<N> object.
   */
   template <int N>
   int AtomMap::findGroupLocalAtoms(Group<N>& group) const
   {
      Atom* ptr;
      int nAtom = 0;
      for (int i = 0; i < N; ++i) {
         ptr = atomPtrs_[group.atomId(i)];
         if (ptr) {
            assert(!ptr->isGhost());
            assert(ptr->id() == group.atomId(i));
            group.setAtomPtr(i, ptr);
            ++nAtom;
         } else {
            group.clearAtomPtr(i);
         }
      }
      return nAtom;
   }

   /*
   * Set pointers to atoms in a Group<N> object.
   */
   template <int N>
   int AtomMap::findGroupGhostAtoms(Group<N>& group) const
   {
      Atom* ptr;
      int nAtom = 0;
      for (int i = 0; i < N; ++i) {
         if (group.atomPtr(i) != 0) {
            // assert(!(ptr->isGhost()));
            ++nAtom;
         } else {
            int atomId = group.atomId(i);
            ptr = atomPtrs_[atomId];
            if (ptr) {
               assert(ptr->isGhost());
               assert(ptr->id() == atomId);
               group.setAtomPtr(i, ptr);
               ++nAtom;
            } else {
               group.clearAtomPtr(i);
            }
         }
      }
      return nAtom;
   }

}
#endif