mcMd/chemistry/Molecule.h

#ifndef MCMD_MOLECULE_H
#define MCMD_MOLECULE_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 "Atom.h"
#ifdef SIMP_BOND
#include "Bond.h"
#endif
#ifdef SIMP_ANGLE
#include "Angle.h"
#endif
#ifdef SIMP_DIHEDRAL
#include "Dihedral.h"
#endif
#include <util/containers/ArrayIterator.h>
#include <util/containers/ConstArrayIterator.h>
#include <util/global.h>

namespace Simp {
   class   Species;
}

namespace McMd
{

   using namespace Util;
   using namespace Simp;

   class   System;

   class Molecule
   {

   public:

      // Typedefs

      typedef ArrayIterator<Atom>  AtomIterator;

      typedef ConstArrayIterator<Atom>  ConstAtomIterator;

      #ifdef SIMP_BOND
      typedef ArrayIterator<Bond>  BondIterator;

      typedef ConstArrayIterator<Bond>  ConstBondIterator;
      #endif

      #ifdef SIMP_ANGLE
      typedef ArrayIterator<Angle>  AngleIterator;

      typedef ConstArrayIterator<Angle>  ConstAngleIterator;
      #endif

      #ifdef SIMP_DIHEDRAL
      typedef ArrayIterator<Dihedral>  DihedralIterator;

      typedef ConstArrayIterator<Dihedral>  ConstDihedralIterator;
      #endif

      static const int NullIndex = -1;

      // Member functions

      Molecule();


      void setSpecies(Species &species);

      void setSystem(System &system);

      void unsetSystem();

      void setId(int id);

      void setFirstAtom(Atom &atom);

      void setNAtom(int nAtom);

      #ifdef SIMP_BOND

      void setFirstBond(Bond &bond);

      void setNBond(int nBond);
      #endif

      #ifdef SIMP_ANGLE

      void setFirstAngle(Angle &angle);

      void setNAngle(int nAngle);
      #endif

      #ifdef SIMP_DIHEDRAL

      void setFirstDihedral(Dihedral &dihedral);

      void setNDihedral(int nDihedral);
      #endif



      Species& species() const;

      System& system() const;

      int id() const;

      int nAtom() const;

      #ifdef SIMP_BOND
      int nBond() const;
      #endif

      #ifdef SIMP_ANGLE
      int nAngle() const;
      #endif

      #ifdef SIMP_DIHEDRAL
      int nDihedral() const;
      #endif

      const Atom& atom(int localId) const;

      Atom& atom(int localId);

      #ifdef SIMP_BOND

      Bond& bond(int localId);

      const Bond& bond(int localId) const;
      #endif

      #ifdef SIMP_ANGLE

      Angle& angle(int localId);

      const Angle& angle(int localId) const;
      #endif

      #ifdef SIMP_DIHEDRAL

      Dihedral& dihedral(int localId);

      const Dihedral& dihedral(int localId) const;
      #endif



      void begin(AtomIterator &iterator);

      void begin(ConstAtomIterator &iterator) const;

      #ifdef SIMP_BOND

      void begin(BondIterator &iterator);

      void begin(ConstBondIterator &iterator) const;
      #endif

      #ifdef SIMP_ANGLE

      void begin(AngleIterator &iterator);

      void begin(ConstAngleIterator &iterator) const;
      #endif

      #ifdef SIMP_DIHEDRAL

      void begin(DihedralIterator &iterator);

      void begin(ConstDihedralIterator &iterator) const;
      #endif


   private:

      Species* speciesPtr_;

      System* systemPtr_;

      Atom* firstAtomPtr_;

      #ifdef SIMP_BOND
      Bond* firstBondPtr_;
      #endif

      #ifdef SIMP_ANGLE
      Angle* firstAnglePtr_;
      #endif

      #ifdef SIMP_DIHEDRAL
      Dihedral* firstDihedralPtr_;
      #endif

      int nAtom_;

      #ifdef SIMP_BOND
      int nBond_;
      #endif

      #ifdef SIMP_ANGLE
      int nAngle_;
      #endif

      #ifdef SIMP_DIHEDRAL
      int nDihedral_;
      #endif

      int id_;

   // friends:

      class DeActivator;

   };

   // Inline member functions

   /*
   * Get the Species by reference.
   */
   inline Species& Molecule::species() const
   {
      assert(speciesPtr_);
      return *speciesPtr_;
   }

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

   /*
   * Get number of atoms in this molecule.
   */
   inline int Molecule::nAtom() const
   {  return nAtom_; }

   #ifdef SIMP_BOND
   /*
   * Get number of bonds in this molecule.
   */
   inline int Molecule::nBond() const
   {  return nBond_; }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Get number of angles in this molecule.
   */
   inline int Molecule::nAngle() const
   {  return nAngle_; }
   #endif

   #ifdef SIMP_DIHEDRAL
   /*
   * Get number of dihedrals in this molecule.
   */
   inline int Molecule::nDihedral() const
   {  return nDihedral_; }
   #endif

   /*
   * Get a specific Atom, referenced by an index.
   */
   inline Atom& Molecule::atom(int localIndex)
   {
      assert(firstAtomPtr_);
      assert(localIndex >= 0);
      assert(localIndex < nAtom_);
      return *(firstAtomPtr_ + localIndex);
   }

   /*
   * Get a specific Atom, referenced by an index.
   */
   inline const Atom& Molecule::atom(int localIndex) const
   {
      assert(firstAtomPtr_);
      assert(localIndex >= 0);
      assert(localIndex < nAtom_);
      return *(firstAtomPtr_ + localIndex);
   }

   #ifdef SIMP_BOND
   /*
   * Get a specific Bond by reference.
   */
   inline Bond& Molecule::bond(int localIndex)
   {
      assert(firstBondPtr_);
      assert(localIndex >= 0);
      assert(localIndex < nBond_);
      return *(firstBondPtr_ + localIndex);
   }

   /*
   * Get a specific Bond by const reference.
   */
   inline const Bond& Molecule::bond(int localIndex) const
   {
      assert(firstBondPtr_);
      assert(localIndex >= 0);
      assert(localIndex < nBond_);
      return *(firstBondPtr_ + localIndex);
   }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Get a specific Angle, referenced by an index.
   */
   inline Angle& Molecule::angle(int localIndex)
   {
      assert(firstAnglePtr_);
      assert(localIndex >= 0);
      assert(localIndex < nAngle_);
      return *(firstAnglePtr_ + localIndex);
   }

   /*
   * Get a specific Angle, referenced by an index.
   */
   inline const Angle& Molecule::angle(int localIndex) const
   {
      assert(firstAnglePtr_);
      assert(localIndex >= 0);
      assert(localIndex < nAngle_);
      return *(firstAnglePtr_ + localIndex);
   }
   #endif

   #ifdef SIMP_DIHEDRAL
   /*
   * Get a specific Dihedral, referenced by an index.
   */
   inline Dihedral& Molecule::dihedral(int localIndex)
   {
      assert(firstDihedralPtr_);
      assert(localIndex >= 0);
      assert(localIndex < nDihedral_);
      return *(firstDihedralPtr_ + localIndex);
   }

   /*
   * Get a specific Dihedral, referenced by an index.
   */
   inline const Dihedral& Molecule::dihedral(int localIndex) const
   {
      assert(firstDihedralPtr_);
      assert(localIndex >= 0);
      assert(localIndex < nAngle_);
      return *(firstDihedralPtr_ + localIndex);
   }
   #endif

   /*
   * Get global index for this Molecule.
   */
   inline int Molecule::id() const
   {  return id_; }

   /*
   * Set AtomIterator to first Atom in this molecule.
   */
   inline void Molecule::begin(AtomIterator &iterator)
   {
      assert(firstAtomPtr_);
      assert(nAtom_ > 0);
      iterator.setCurrent(firstAtomPtr_);
      iterator.setEnd(firstAtomPtr_ + nAtom_);
   }

   /*
   * Set AtomIterator to first Atom in this molecule.
   */
   inline void Molecule::begin(ConstAtomIterator &iterator) const
   {
      assert(firstAtomPtr_);
      assert(nAtom_ > 0);
      iterator.setCurrent(firstAtomPtr_);
      iterator.setEnd(firstAtomPtr_ + nAtom_);
   }

   #ifdef SIMP_BOND
   /*
   * Set BondIterator to first Bond in this molecule.
   */
   inline void Molecule::begin(BondIterator &iterator)
   {
      assert(firstBondPtr_);
      assert(nBond_ > 0);
      iterator.setCurrent(firstBondPtr_);
      iterator.setEnd(firstBondPtr_ + nBond_);
   }

   /*
   * Set ConstBondIterator to first Bond in this molecule.
   */
   inline void Molecule::begin(ConstBondIterator &iterator) const
   {
      assert(firstBondPtr_);
      assert(nBond_ > 0);
      iterator.setCurrent(firstBondPtr_);
      iterator.setEnd(firstBondPtr_ + nBond_);
   }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Set AngleIterator to first Angle in this molecule.
   */
   inline void Molecule::begin(AngleIterator &iterator)
   {
      assert(firstAnglePtr_);
      assert(nAngle_ > 0);
      iterator.setCurrent(firstAnglePtr_);
      iterator.setEnd(firstAnglePtr_ + nAngle_);
   }

   /*
   * Set ConstAngleIterator to first Angle in this molecule.
   */
   inline void Molecule::begin(ConstAngleIterator &iterator) const
   {
      assert(firstAnglePtr_);
      assert(nAngle_ > 0);
      iterator.setCurrent(firstAnglePtr_);
      iterator.setEnd(firstAnglePtr_ + nAngle_);
   }
   #endif

   #ifdef SIMP_DIHEDRAL
   /*
   * Set DihedralIterator to first Dihedral in this molecule.
   */
   inline void Molecule::begin(DihedralIterator &iterator)
   {
      assert(firstDihedralPtr_);
      assert(nDihedral_ > 0);
      iterator.setCurrent(firstDihedralPtr_);
      iterator.setEnd(firstDihedralPtr_ + nDihedral_);
   }

   /*
   * Set ConstDihedralIterator to first Dihedral in this molecule.
   */
   inline void Molecule::begin(ConstDihedralIterator &iterator) const
   {
      assert(firstDihedralPtr_);
      assert(nDihedral_ > 0);
      iterator.setCurrent(firstDihedralPtr_);
      iterator.setEnd(firstDihedralPtr_ + nDihedral_);
   }
   #endif

   /*
   * Set pointer to molecular Species.
   */
   inline void Molecule::setSpecies(Species &species)
   {  speciesPtr_ = &species; }

   /*
   * Set pointer to parent System.
   */
   inline void Molecule::setSystem(System &system)
   {  systemPtr_ = &system; }

   /*
   * Set the pointer to the parent System to null.
   */
   inline void Molecule::unsetSystem()
   {  systemPtr_ = 0; }

   /*
   * Set pointer to first Atom in molecule.
   */
   inline void Molecule::setFirstAtom(Atom &atom)
   {  firstAtomPtr_ = &atom; }

   /*
   * Set number of atoms per molecule.
   */
   inline void Molecule::setNAtom(int nAtom)
   {  nAtom_ = nAtom; }

   #ifdef SIMP_BOND
   /*
   * Set pointer to first Bond in molecule.
   */
   inline void Molecule::setFirstBond(Bond &bond)
   {  firstBondPtr_ = &bond; }

   /*
   * Set number of bonds per molecule.
   */
   inline void Molecule::setNBond(int nBond)
   {  nBond_ = nBond; }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Set pointer to first Angle in molecule.
   */
   inline void Molecule::setFirstAngle(Angle &angle)
   {  firstAnglePtr_ = &angle; }

   /*
   * Set number of angles per molecule.
   */
   inline void Molecule::setNAngle(int nAngle)
   {  nAngle_ = nAngle; }
   #endif

   #ifdef SIMP_DIHEDRAL
   /*
   * Set pointer to first Dihedral in molecule.
   */
   inline void Molecule::setFirstDihedral(Dihedral &dihedral)
   {  firstDihedralPtr_ = &dihedral; }

   /*
   * Set number of dihedrals per molecule.
   */
   inline void Molecule::setNDihedral(int nDihedral)
   {  nDihedral_ = nDihedral; }
   #endif

   /*
   * Set global index.
   */
   inline void Molecule::setId(int id)
   {  id_ = id; }

   // Inline member function of Atom class.

   /*
   * Return local id of an Atom within its parent molecule.
   *
   * This function is defined here, rather than in Atom.h, because its
   * implementation requires the inline method Molecule::atom(int).
   */
   inline int Atom::indexInMolecule() const
   {  return int(this - &molecule().atom(0));}

}
#endif