SystemInterface.h

#ifndef MCMD_SYSTEM_INTERFACE_H
#define MCMD_SYSTEM_INTERFACE_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>               // parent (provides typedefs)
#include <mcMd/chemistry/Molecule.h>              // member template parameter
#include <simp/boundary/Boundary.h>               // member

#include <util/containers/DArray.h>               // member template
#include <util/containers/PArrayIterator.h>       // inline function begin()
#include <util/global.h>

#include <iostream>
#include <string>

namespace McMd
{

   class Simulation;

   using namespace Util;
   using namespace Simp;

   class SystemInterface
   {

   public:

      SystemInterface(System& parent);

      virtual ~SystemInterface();

      System& system() const;

   protected:



      Boundary& boundary() const;

      Simulation& simulation() const;



      int nMolecule(int speciesId) const;

      int nAtom() const;

      bool isEmpty() const;

      void begin(int speciesId, System::MoleculeIterator& iterator);

      void begin(int speciesId, System::ConstMoleculeIterator& iterator) const;



      #ifdef SIMP_BOND
      bool hasBonds() const;
      #endif

      #ifdef SIMP_ANGLE
      bool hasAngles() const;
      #endif

      #ifdef SIMP_DIHEDRAL
      bool hasDihedrals() const;
      #endif

      #ifdef MCMD_LINK
      bool hasLinks() const;
      #endif

      #ifdef SIMP_EXTERNAL
      bool hasExternal() const;
      #endif

      #ifdef SIMP_TETHER
      bool hasTethers() const;
      #endif


   private:

      Simulation* simulationPtr_;

      System* systemPtr_;

      DArray< System::MoleculeSet >* moleculeSetsPtr_;

      Boundary*   boundaryPtr_;

      #ifdef SIMP_BOND
      // Does a bond potential exist?
      bool hasBonds_;
      #endif

      #ifdef SIMP_ANGLE
      // Does an angle potential exist?
      bool hasAngles_;
      #endif

      #ifdef SIMP_DIHEDRAL
      // Does a dihedral potential exist?
      bool hasDihedrals_;
      #endif

      #ifdef MCMD_LINK
      // Does a link potential exist?
      bool hasLinks_;
      #endif

      #ifdef SIMP_EXTERNAL
      // Does an external potential exist?
      bool hasExternal_;
      #endif

      #ifdef SIMP_TETHER
      // Does a tether potential exist?
      bool hasTethers_;
      #endif

   };

   // Inline functions

   /*
   * Get the parent Simulation by reference.
   */
   inline Simulation& SystemInterface::simulation() const
   {
      assert(simulationPtr_);
      return *simulationPtr_;
   }

   /*
   * Get the parent System by reference.
   */
   inline System& SystemInterface::system() const
   {
      assert(systemPtr_);
      return *systemPtr_;
   }

   /*
   * Get the Boundary by reference.
   */
   inline Boundary& SystemInterface::boundary() const
   {
      assert(boundaryPtr_);
      return *boundaryPtr_;
   }

   /*
   * Get the number of molecules of a specific Species in this SystemInterface.
   */
   inline int SystemInterface::nMolecule(int speciesId) const
   {
      assert(moleculeSetsPtr_);
      return (*moleculeSetsPtr_)[speciesId].size();
   }

   /*
   * Initialize a System::MoleculeIterator for molecules of one Species.
   */
   inline void
   SystemInterface::begin(int speciesId, System::MoleculeIterator& iterator)
   {
      assert(moleculeSetsPtr_);
      (*moleculeSetsPtr_)[speciesId].begin(iterator);
   }

   /*
   * Initialize a System::ConstMoleculeIterator for molecules of one Species.
   */
   inline void
   SystemInterface::begin(int speciesId, System::ConstMoleculeIterator& iterator) const
   {
      assert(moleculeSetsPtr_);
      (*moleculeSetsPtr_)[speciesId].begin(iterator);
   }

   #ifdef SIMP_BOND
   /*
   * Does a bond potential exist?
   */
   inline bool SystemInterface::hasBonds() const
   {  return hasBonds_; }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Does an angle potential exist?
   */
   inline bool SystemInterface::hasAngles() const
   {  return hasAngles_; }
   #endif

   #ifdef SIMP_DIHEDRAL
   inline bool SystemInterface::hasDihedrals() const
   {  return hasDihedrals_; }
   #endif

   #ifdef MCMD_LINK
   inline bool SystemInterface::hasLinks() const
   { return hasLinks_; }
   #endif

   #ifdef SIMP_EXTERNAL
   inline bool SystemInterface::hasExternal() const
   { return hasExternal_; }
   #endif

   #ifdef SIMP_TETHER
   inline bool SystemInterface::hasTethers() const
   { return hasTethers_; }
   #endif

}
#endif