mcMd/neighbor/Cell.h

#ifndef MCMD_CELL_H
#define MCMD_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 "CellTag.h" 
#include <util/containers/Array.h> 
#include <util/global.h>

class CellTest;
class CellListTest;

namespace McMd
{

   using namespace Util;

   class Atom;
   
   class Cell 
   {
     
   public:

      #ifdef SIMP_COULOMB
      static const int MaxAtomCell = 253; 
      #else
      static const int MaxAtomCell = 61; 
      #endif
   
      static const int NullIndex   = -1; 
   
      Cell();
   
      void clear();
   
      void deleteAtom(CellTag &cellTag);
    
      void addAtom(CellTag &cellTag, Atom &atom, int cellId);
 
      int nAtomCell() const;

      int firstClearPos() const; 
        
      Atom* atomPtr(int index) const;
        
      bool isValid(const Array<CellTag> &cellTags, int nAtom, int icell) const;
   
   private:
   
      /*
      * Implementation notes:
      *
      * Pointers to atoms in a cell are stored in the atoms_[] array member.
      * "Empty" elements of atoms_[] must contain a null (i.e., 0) pointer.
      *
      * The total number of atoms in the cell in is nAtomCell_. The array 
      * index of the first empty element in the atoms_[] array is given by 
      * firstEmptyPos_. All elements of atoms_[] with indices greater than 
      * or equal to firstClearPos_ are empty. An element atoms_[i] with 
      * i < firstEmptyPos_ may not be empty, one with i >= firstClearPos_ must 
      * be empty, and one with firstEmptyPos_ < i < firstClearPos_ may or may
      * not be empty. When firstClearPos_ > 0, atoms_[firstClearPos_-1] may 
      * not be empty, since this would imply that firstClearPos_ is not the 
      * first in the contiguous block of empty elements. These conditions are 
      * checked in the isValid() method. 
      */
   
      Atom* atoms_[MaxAtomCell]; 
   
      int   nAtomCell_;   
   
      int   firstEmptyPos_;  
   
      int   firstClearPos_; 

   //friends:

      //  Grant access to unit test classes
      friend class ::CellTest;
      friend class ::CellListTest;

   }; 
  
   // Inline functions
   
   /* 
   * Delete atom from Cell
   */
   inline void Cell::deleteAtom(CellTag &cellTag) 
   {
      int cellPos = cellTag.cellPos;
   
      // Delete atom from Cell member variables.
      // Set atoms_[cellPos] to 0 to mark empty.
      atoms_[cellPos] = 0;
      nAtomCell_--;
   
      // Reset firstEmptyPos_
      if (firstEmptyPos_ > cellPos) {
         firstEmptyPos_ = cellPos;
      }
   
      // Reset firstClearPos_
      int i = firstClearPos_ - 1;
      while (i >= 0 && atoms_[i] == 0) {
         i--;
      }
      firstClearPos_ = i + 1;
   
      // Reset cellTag cellId and cellPos to negative integer values 
      // to indicate that the atom is no longer associated with a Cell.
      cellTag.cellId  = NullIndex;
      cellTag.cellPos = NullIndex;
   
   }
   
   /* 
   * Add a atom to a Cell
   */
   inline void Cell::addAtom(CellTag &cellTag, Atom &atom, int cellId) 
   {
   
      // If cell is already full, throw Exception
      if (firstEmptyPos_ == MaxAtomCell) {
         UTIL_THROW("Too many atoms in one cell");
      }
       
      // Add atom to Cell
      atoms_[firstEmptyPos_] = &atom;
      ++nAtomCell_;
   
      // Record cell in cellTag
      cellTag.cellId  = cellId;
      cellTag.cellPos = firstEmptyPos_;
   
      // Reset firstEmptyPos_ and firstClearPos_
      if (firstEmptyPos_ < MaxAtomCell - 1) {
   
         if (firstEmptyPos_ == firstClearPos_) {
   
            firstEmptyPos_ = firstEmptyPos_ + 1;
            firstClearPos_ = firstClearPos_ + 1;
   
         } else {
   
            // Find the next empty element, for which atoms_[i] is null
            for (int i = firstEmptyPos_ + 1; i < MaxAtomCell; ++i) {
               if (atoms_[i] == 0) {
                  firstEmptyPos_ = i;
                  break;
               }
            }
   
         }
   
      } else { 
   
         // If firstEmptyPos_ was MaxAtomCell - 1, no empty slots remain.
         // Set firstEmptyPos_ = MaxAtomCell to indicate this condition.
         // Attempting to add one more atom will trigger an Exception.
         firstEmptyPos_ = MaxAtomCell;  // Note: Invalid array index
         firstClearPos_ = MaxAtomCell;  // Note: Invalid array index
   
      }
   }

   inline int Cell::nAtomCell() const
   { return nAtomCell_; }
         
   inline int Cell::firstClearPos() const
   { return firstClearPos_; }

   inline Atom* Cell::atomPtr(int index) const
   { return atoms_[index]; }
         
} 

#endif