ddMd/neighbor/Cell.h

#ifndef DDMD_CELL_H
#define DDMD_CELL_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/neighbor/CellAtom.h>
#include <ddMd/chemistry/Atom.h>
#include <util/containers/FSArray.h>
#include <util/global.h>

#include <utility>

namespace DdMd
{

   using namespace Util;

   class Cell
   {

   public:

      // Static members

      static const int MaxNeighborAtom = 2000;

      static const int MaxNCellCut = 4;
      
      static const int OffSetArrayCapacity = (2*MaxNCellCut + 1)*(2*MaxNCellCut + 1) + 3;
    
      typedef FSArray< std::pair<int,int>, OffSetArrayCapacity> OffsetArray;

      typedef FSArray<CellAtom*, MaxNeighborAtom> NeighborArray;

      Cell();

      // Linked List Interface

      void setNextCell(Cell& nextCell);

      void setLastCell();

      const Cell* nextCellPtr() const;

      // Mutators 

      void setId(int id);

      void setOffsetArray(OffsetArray& offsets);

      void setIsGhostCell(bool isGhostCell = true);

      void clear();

      void incrementCapacity();

      CellAtom* initialize(CellAtom* begin);

      void append(Atom* atomPtr);

      // Accessors

      int id() const;
  
      int nAtom() const;

      int atomCapacity() const;

      CellAtom* atomPtr(int i) const;

      bool isGhostCell() const;

      void getNeighbors(NeighborArray& neighbors, 
                        bool reverseUpdateFlag = false) const;

   private:

      CellAtom* begin_;         

      OffsetArray* offsetsPtr_;

      Cell* nextCellPtr_;

      int nAtom_;

      int atomCapacity_;  

      int id_;

      bool isGhostCell_;

   };

   inline void Cell::setId(int id) 
   {  id_ = id; }

   inline void Cell::incrementCapacity()
   {
      assert(begin_ == 0);
      ++atomCapacity_;
   }

   inline void Cell::clear()
   {
      begin_= 0;
      nAtom_ = 0;
      atomCapacity_ = 0;
   }

   inline CellAtom* Cell::initialize(CellAtom* begin)
   {
      assert(begin_ == 0);
      assert(nAtom_ == 0);
      assert(atomCapacity_  >= 0);

      begin_ = begin; 
      return (begin_ + atomCapacity_);
   }

   inline void Cell::append(Atom* atomPtr)
   {
      assert(begin_ != 0);
      assert(nAtom_ < atomCapacity_);
      begin_[nAtom_].setPtr(atomPtr);
      ++nAtom_;
   }

   /*
   * Get identifier for this Cell.
   */
   inline int Cell::id() const
   {  return id_; }
  
   /*
   * Return number of atoms in this cell.
   */
   inline int Cell::nAtom() const
   {  return nAtom_; }

   /*
   * Return pointer to atom i.
   */
   inline CellAtom* Cell::atomPtr(int i) const
   {
      assert(i >= 0);
      assert(i < nAtom_);
      return &begin_[i];
   }

   /*
   * Pointer to next cell in list.
   */
   inline const Cell* Cell::nextCellPtr() const
   {  return nextCellPtr_; }

   /*
   *  Return current capacity of cell. 
   */
   inline int Cell::atomCapacity() const
   {  return atomCapacity_; }

   /*
   * Is this a ghost cell?
   */
   inline bool Cell::isGhostCell() const
   {  return isGhostCell_; }

}
#endif