ddMd/potentials/pair/PairPotential.h

#ifndef DDMD_PAIR_POTENTIAL_H
#define DDMD_PAIR_POTENTIAL_H

#include <ddMd/potentials/Potential.h>  // base class
#include <ddMd/neighbor/CellList.h>     // member
#include <ddMd/neighbor/PairList.h>     // member
#include <ddMd/misc/DdTimer.h>          // member
#include <simp/boundary/Boundary.h>     // member (typedef)
#include <util/global.h>

#include <iostream>

#define DDMD_PAIR_POTENTIAL_TIMER

/*
* 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.
*/

namespace Util
{  class Tensor; }

namespace DdMd
{

   class Simulation;
   class AtomStorage;
   class Domain;

   using namespace Util;
   using namespace Simp;

   class PairPotential : public Potential
   {

   public:

      PairPotential(Simulation& simulation);

      PairPotential();

      virtual ~PairPotential();



      void associate(Domain& domain, Boundary& boundary, AtomStorage& storage);

      virtual void setNAtomType(int nAtomType) = 0;
 
      void 
      initialize(const Boundary& maxBoundary, double skin, int pairCapacity);

      void readParameters(std::istream& in);

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

      virtual void save(Serializable::OArchive &ar);
  
      void setMethodId(int methodId);



      virtual 
      double pairEnergy(double rsq, int iAtomType, int jAtomType) const = 0;

      virtual 
      double pairForceOverR(double rsq, int iAtomType, int jAtomType) const = 0;

      virtual void set(std::string name, int i, int j, double value) = 0;

      virtual double get(std::string name, int i, int j) const = 0;

      virtual double maxPairCutoff() const = 0;

      virtual std::string interactionClassName() const = 0;



      void buildCellList();

      void buildPairList();

      #ifdef UTIL_MPI
      virtual void computePairEnergies(MPI::Intracomm& communicator) = 0;
      #else
      virtual void computePairEnergies() = 0;
      #endif

      DMatrix<double> pairEnergies() const;

      void unsetPairEnergies();

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

      int nPair() const;

      CellList& cellList();

      PairList& pairList();


      double skin() const;

      double cutoff() const;

      int methodId() const;

   protected:

      CellList cellList_;

      PairList pairList_;

      Boundary maxBoundary_;

      double skin_;

      double cutoff_;

      int nCellCut_;

      int pairCapacity_;

      Boundary& boundary();

      Domain& domain();

      AtomStorage& storage();

      void setPairEnergies(DMatrix<double> pairEnergies);

   private:

      Domain* domainPtr_;

      Boundary* boundaryPtr_;

      AtomStorage* storagePtr_;

      int methodId_;

      int nPair_;

      Setable< DMatrix<double> > pairEnergies_;

      int nPairList(double cutoffSq);
      int nPairCell(double cutoffSq);
      int nPairNSq(double cutoffSq);

      void allocate();

   };

   inline CellList& PairPotential::cellList()
   {  return cellList_; }

   inline PairList& PairPotential::pairList()
   {  return pairList_; }

   inline double PairPotential::skin() const
   {  return skin_; }

   inline double PairPotential::cutoff() const
   {  return cutoff_; }

   inline Boundary& PairPotential::boundary() 
   {  return *boundaryPtr_; }

   inline Domain& PairPotential::domain()
   {  return *domainPtr_; }

   inline AtomStorage& PairPotential::storage()
   {  return *storagePtr_; }

   inline void PairPotential::setMethodId(int methodId)
   {  methodId_ = methodId; }

   inline int PairPotential::methodId() const
   {  return methodId_; }

}
#endif