ddMd/neighbor/PairList.h

#ifndef DDMD_PAIR_LIST_H
#define DDMD_PAIR_LIST_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 "CellList.h"
#include <util/containers/GArray.h>
#include <util/misc/Setable.h>
#include <util/global.h>

namespace DdMd
{

   using namespace Util;

   class Atom;
   class PairIterator;
   
   class PairList 
   {

      // Null value for any non-negative index
      static const int NullIndex = -1;   

   public:
  
      PairList();
   
      virtual ~PairList();
   


      void allocate(int atomCapacity, int pairCapacity, double cutoff);

      void clear();

      void build(CellList& cellList, bool reverseUpdateFlag = false);


 
      void begin(PairIterator &iterator) const;
 
      int nAtom() const;

      int nPair() const;

      int pairCapacity() const;

      int atomCapacity() const;

      bool isAllocated() const;
 

 
      #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 maxNPair() const;

      int buildCounter() const;


   private:
  
      GArray<Atom*>  atom1Ptrs_;  

      GArray<Atom*>  atom2Ptrs_;  

      GArray<int>  first_; 

      double cutoff_;
   
      int  atomCapacity_;     
   
      int  pairCapacity_;     
   
      int  maxNAtomLocal_;     
   
      int  maxNPairLocal_;     
   
      int  buildCounter_;

      Setable<int>  maxNAtom_;     
   
      Setable<int>  maxNPair_;     
   
      bool  isAllocated_;
  
      /* 
      * Implementation Notes:
      *
      * The pair list is stored in Atom* pointer arrays atom1Ptrs_, atom2Ptrs_, 
      * and in an integer array first_. Each element of atom1Ptrs_ contains a 
      * pointer to the first atom in a pair (the primary Atom). Each element 
      * of atom2Ptrs_ contains a pointer to the second atom in a pair (the 
      * secondary Atom).  Secondary atoms that are neighbors of the same 
      * primary atom are listed consecutively.  Element first_[i] contains the 
      * array index of the first element in atom2Ptrs_ that contains a neighbor 
      * of primary atom atom1Ptrs_[i]. Pointers to neighbors of primary atom
      * *atom1Ptrs_[i] are thus stored in elements first_[i] <= j < first_[i+1]
      * of atom2Ptrs_.  Each pair is included only once.
      *
      * The only way legal way to loop over all atom pairs, using the public 
      * interface of a PairList, is to use a PairListIterator. See the 
      * documentation of PairListIterator for a discussion of its usage. The 
      * resulting loop over pairs is equivalent to the following double loop 
      * over private member variables of PairList:
      * 
      *    int i, j;
      *    Atom* atom1Ptr;
      *    Atom* atom2Ptr;
      *
      *    \\ Loop over primary Atoms
      *    for (i = 0; i < atom1Ptrs_.size(); ++i) {
      *       atom1Ptr = atom1Ptrs_[i];
      *
      *       // Loop over secondary atoms
      *       for (j = first_[i]; j < first_[i+1]; ++j) {
      *           atom2Ptr = atom2Ptrs_[j];
      *
      *           // ... Do something with Atoms *atom1Ptr and *atom2Ptr.
      *
      *       }
      *    }
      *
      * Note that GArray<int> first_ contains one more elements than 
      * atom1Ptrs_. The element first_[0] is equal to 0, and the last 
      * element is always equal to the total number of pairs.
      */

   }; 

   /*
   * Get the current number of primary atoms in the pairlist.
   */ 
   inline int PairList::nAtom() const
   {  return atom1Ptrs_.size(); }

   /*
   * Get the current number of pairs.
   */ 
   inline int PairList::nPair() const
   {  return atom2Ptrs_.size(); }

   inline int PairList::pairCapacity() const
   {  return pairCapacity_; }

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

   /*
   * Get the maximum value of aAtom() since instantiation.
   */ 
   inline int PairList::maxNAtom() const
   { return maxNAtom_.value(); }

   /*
   * Get the maximum value of nPair() since instantiation.
   */ 
   inline int PairList::maxNPair() const
   { return maxNPair_.value(); }

   /*
   * Get the number of times this PairList has been built.
   */ 
   inline int PairList::buildCounter() const
   { return buildCounter_; }

   /*
   * Has memory been allocated for this PairList?
   */ 
   inline bool PairList::isAllocated() const
   { return isAllocated_; }

} 
#endif