McSystem.h

#ifndef MCMD_MC_SYSTEM_H
#define MCMD_MC_SYSTEM_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 <mcMd/simulation/System.h>     // base class
#include <mcMd/neighbor/CellList.h>     // member
#include <util/signal/Signal.h>         // members
#include <util/global.h>

namespace McMd
{

   using namespace Util;

   class Atom;
   #ifndef SIMP_NOPAIR
   class McPairPotential;
   #endif
   #ifdef SIMP_BOND
   class BondPotential;
   #endif
   #ifdef SIMP_ANGLE
   class AnglePotential;
   #endif
   #ifdef SIMP_DIHEDRAL
   class DihedralPotential;
   #endif
   #ifdef SIMP_COULOMB
   class CoulombPotential;
   #endif
   #ifdef SIMP_EXTERNAL
   class ExternalPotential;
   #endif
   #ifdef SIMP_TETHER
   class TetherPotential;
   #endif

   class McSystem : public System
   {

   public:

      McSystem();

      virtual ~McSystem();



      virtual void readParameters(std::istream &in);

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

      virtual void saveParameters(Serializable::OArchive &ar);



      using System::readConfig;

      virtual void readConfig(std::istream& in);

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

      virtual 
      void generateMolecules(Array<int> const & capacities,
                             Array<double> const & diameters);



      double atomPotentialEnergy(const Atom& atom) const;

      double potentialEnergy() const;

      template <typename T>
      void computeVirialStress(T& stress) const;

      template <typename T>
      void computeStress(T& stress) const;

      void unsetPotentialEnergies();

      void unsetVirialStress();



      #ifndef SIMP_NOPAIR

      McPairPotential& pairPotential() const;
      #endif

      #ifdef SIMP_BOND

      bool hasBondPotential() const;

      BondPotential& bondPotential() const;
      #endif

      #ifdef SIMP_ANGLE

      bool hasAnglePotential() const;

      AnglePotential& anglePotential() const;
      #endif

      #ifdef SIMP_DIHEDRAL

      bool hasDihedralPotential() const;

      DihedralPotential& dihedralPotential() const;
      #endif

      #ifdef SIMP_COULOMB

      bool hasCoulombPotential() const;

      CoulombPotential& coulombPotential() const;
      #endif

      #ifdef SIMP_EXTERNAL

      bool hasExternalPotential() const;

      ExternalPotential& externalPotential() const;
      #endif

      #ifdef MCMD_LINK

      bool hasLinkPotential() const;

      BondPotential& linkPotential() const;
      #endif

      #ifdef SIMP_TETHER

      TetherPotential& tetherPotential() const;
      #endif



      Signal<>& positionSignal();

      virtual bool isValid() const;


   protected:

      #ifdef MCMD_PERTURB

      virtual Factory<Perturbation>* newDefaultPerturbationFactory();
      #endif

      #ifndef SIMP_NOPAIR

      void setPairPotential(McPairPotential* pairPotentialPtr);
      #endif

   private:

      #ifndef SIMP_NOPAIR
      mutable CellList::NeighborArray neighbors_;

      McPairPotential* pairPotentialPtr_;
      #endif

      #ifdef SIMP_BOND
      BondPotential* bondPotentialPtr_;
      #endif

      #ifdef SIMP_ANGLE
      AnglePotential* anglePotentialPtr_;
      #endif

      #ifdef SIMP_DIHEDRAL
      DihedralPotential* dihedralPotentialPtr_;
      #endif

      #ifdef SIMP_COULOMB
      CoulombPotential* coulombPotentialPtr_;
      #endif

      #ifdef SIMP_EXTERNAL
      ExternalPotential* externalPotentialPtr_;
      #endif

      #ifdef MCMD_LINK
      BondPotential* linkPotentialPtr_;
      #endif

      #ifdef SIMP_TETHER
      TetherPotential* tetherPotentialPtr_;
      #endif

      Signal<>  positionSignal_;

      /*
      * Implementations of the explicit specializations of the public
      * stress calculators computeStress(T& ) etc. for T = double,
      * Util::Vector and Util::Tensor simply call these private method
      * templates. This allows a single template method to be used to
      * compile the 3 relevant explicit specializations of each stress
      * calculator, while keeping the template implementations out of
      * this header file.
      */

      template <typename T>
      void computeVirialStressImpl(T& stress) const;

      #ifdef MCMD_LINK
      template <typename T>
      void computeLinkStressImpl(T& stress) const;
      #endif

   };

   // Inline methods

   #ifndef SIMP_NOPAIR
   /*
   * Return the McPairPotential by reference.
   */
   inline McPairPotential& McSystem::pairPotential() const
   {  
      assert(pairPotentialPtr_);
      return *pairPotentialPtr_; 
   }
   #endif

   #ifdef SIMP_BOND
   /*
   * Does a bond potential exist?
   */
   inline bool McSystem::hasBondPotential() const
   {  return bool(bondPotentialPtr_); }

   /*
   * Return the BondPotential by const reference.
   */
   inline BondPotential& McSystem::bondPotential() const
   {  
      assert(bondPotentialPtr_);
      return *bondPotentialPtr_; 
   }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Does an angle potential exist?
   */
   inline bool McSystem::hasAnglePotential() const
   {  return bool(anglePotentialPtr_); }

   /*
   * Return angle potential by reference.
   */
   inline AnglePotential& McSystem::anglePotential() const
   {  
      assert(anglePotentialPtr_);
      return *anglePotentialPtr_; 
   }
   #endif

   #ifdef SIMP_DIHEDRAL
   /*
   * Does a dihedral potential exist?
   */
   inline bool McSystem::hasDihedralPotential() const
   {  return bool(dihedralPotentialPtr_); }

   /*
   * Return dihedral potential by reference.
   */
   inline DihedralPotential& McSystem::dihedralPotential() const
   {  
      assert(dihedralPotentialPtr_);
      return *dihedralPotentialPtr_; 
   }
   #endif

   #ifdef SIMP_COULOMB
   /*
   * Does a Coulomb potential exist?
   */
   inline bool McSystem::hasCoulombPotential() const
   {  return bool(coulombPotentialPtr_); }

   /*
   * Return Coulomb potential by reference.
   */
   inline CoulombPotential& McSystem::coulombPotential() const
   {  
      assert(coulombPotentialPtr_);  
      return *coulombPotentialPtr_; 
   }
   #endif

   #ifdef SIMP_EXTERNAL
   /*
   * Does an external potential exist?
   */
   inline bool McSystem::hasExternalPotential() const
   {  return bool(externalPotentialPtr_); }

   /*
   * Return external potential by reference.
   */
   inline ExternalPotential& McSystem::externalPotential() const
   {
      assert(externalPotentialPtr_);  
      return *externalPotentialPtr_; 
   }
   #endif

   #ifdef MCMD_LINK
   /*
   * Does a link potential exist?
   */
   inline bool McSystem::hasLinkPotential() const
   {
      assert(linkPotentialPtr_);  
      return bool(linkPotentialPtr_); 
   }

   /*
   * Return link potential by reference.
   */
   inline BondPotential& McSystem::linkPotential() const
   {  return *linkPotentialPtr_; }
   #endif

   #ifdef SIMP_TETHER
   /*
   * Return tether potential by reference.
   */
   inline TetherPotential& McSystem::tetherPotential() const
   { 
      assert(tetherPotentialPtr_);  
      return *tetherPotentialPtr_; 
   }
   #endif

   #ifndef SIMP_NOPAIR
   /*
   * Set the pair potential
   */
   inline void McSystem::setPairPotential(McPairPotential* pairPotentialPtr)
   {  pairPotentialPtr_ = pairPotentialPtr; }
   #endif

   /*
   * Signal to indicate change in atomic positions.
   */
   inline Signal<>& McSystem::positionSignal()
   { return positionSignal_; }

}
#endif