simp/species/Species.h

#ifndef SIMP_SPECIES_H
#define SIMP_SPECIES_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 <util/param/ParamComposite.h>   // base class
#include <util/containers/DArray.h>      // member template
#include <util/containers/FSArray.h>     // member template
#include <simp/species/SpeciesGroup.h>   // member template parameter

namespace McMd {
   class SpeciesMutator;
}

namespace Simp
{

   using namespace Util;


   class Species : public ParamComposite
   {

   public:

      #ifdef SIMP_BOND
      static const int MaxBondPerAtom = 4;

      typedef SpeciesGroup<2> SpeciesBond;

      typedef FSArray<int, MaxBondPerAtom> AtomBondIdArray;
      #endif

      #ifdef SIMP_ANGLE
      static const int MaxAnglePerAtom = 18;

      typedef SpeciesGroup<3> SpeciesAngle;

      typedef FSArray<int, MaxAnglePerAtom> AtomAngleIdArray;
      #endif

      #ifdef SIMP_DIHEDRAL
      static const int MaxDihedralPerAtom = 72;

      typedef SpeciesGroup<4> SpeciesDihedral;

      typedef FSArray<int, MaxDihedralPerAtom> AtomDihedralIdArray;
      #endif

      Species();

      virtual ~Species();



      void setId(int id);
      
      virtual void readParameters(std::istream &in);

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

      void readStructure(std::istream& in);



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

      void writeStructure(std::ostream& out, 
                          std::string indent = std::string());

      bool matchStructure(std::istream& in);


      
      int nAtom() const;

      int atomTypeId(int iAtom) const;

      #ifdef SIMP_BOND

      int nBond() const;

      const SpeciesBond& speciesBond(int iBond) const;

      const AtomBondIdArray& atomBondIds(int atomId) const;
      #endif

      #ifdef SIMP_ANGLE

      int nAngle() const;

      const SpeciesAngle& speciesAngle(int iAngle) const;

      const AtomAngleIdArray& atomAngleIds(int atomId) const;
      #endif

      #ifdef SIMP_DIHEDRAL

      int nDihedral() const;

      const SpeciesDihedral& speciesDihedral(int iDihedral) const;

      const AtomDihedralIdArray& atomDihedralIds(int atomId) const;
      #endif


      
      bool isMutable() const;

      McMd::SpeciesMutator& mutator();



      int id() const;

      int capacity() const;

      bool isValid() const;


   protected:

      // Static constant
 
      static const int NullIndex = -1;

      // Non-static protected variables
      
      // These variables are protected, rather than private, so that they can 
      // be read and written by the (read|write)Param() functions of subclasses.

      int id_;

      int moleculeCapacity_;

      int nAtom_;

      DArray<int> atomTypeIds_;

      #ifdef SIMP_BOND

      int nBond_;

      DArray<SpeciesBond> speciesBonds_;
      #endif

      #ifdef SIMP_ANGLE

      int nAngle_;

      DArray<SpeciesAngle> speciesAngles_;
      #endif

      #ifdef SIMP_DIHEDRAL

      int nDihedral_;

      DArray<SpeciesDihedral> speciesDihedrals_;
      #endif

      // Methods

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

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

      void allocate();

      void allocateAtoms();

      void setAtomType(int atomId, int atomType);

      #ifdef SIMP_BOND

      void allocateBonds();

      void makeBond(int bondId, int atomId1, int atomId2, int bondType);
      #endif

      #ifdef SIMP_ANGLE

      void allocateAngles();

      void makeAngle(int angleId, int atomId1, int atomId2, int atomId3,
                     int angleType);
      #endif

      #ifdef SIMP_DIHEDRAL

      void allocateDihedrals();

      void makeDihedral(int dihedralId, int atomId1, int atomId2, int atomId3,
                     int atomId4, int dihedralType);
      #endif

      void initializeAtomGroupIdArrays();

      void setMutatorPtr(McMd::SpeciesMutator* mutatorPtr);

   private:

      #ifdef SIMP_BOND

      DArray<AtomBondIdArray> atomBondIdArrays_;
      #endif

      #ifdef SIMP_ANGLE

      DArray<AtomAngleIdArray> atomAngleIdArrays_;
      #endif

      #ifdef SIMP_DIHEDRAL

      DArray<AtomDihedralIdArray> atomDihedralIdArrays_;
      #endif

      McMd::SpeciesMutator* mutatorPtr_;

   };

   // Inline member function definitions

   /*
   * Get integer id for this Species.
   */
   inline int Species::id() const
   { return id_; }

   /*
   * Get maximum number of molecules for this Species.
   */
   inline int Species::capacity() const
   { return moleculeCapacity_; }

   /*
   * Get number of Atoms per molecule.
   */
   inline int Species::nAtom() const
   {  return nAtom_; }

   /*
   * Get type index for atom number iAtom.
   */
   inline int Species::atomTypeId(int iAtom) const
   {  return atomTypeIds_[iAtom]; }

   #ifdef SIMP_BOND
   /*
   * Get number of Bonds per molecule
   */
   inline int Species::nBond() const
   {  return nBond_; }

   /*
   * Get a specific SpeciesBond object by local index.
   */
   inline 
   const Species::SpeciesBond& Species::speciesBond(int iBond) const
   {  return speciesBonds_[iBond]; }

   /*
   * Get array of ids for bonds that contain one atom.
   */
   inline 
   const Species::AtomBondIdArray& Species::atomBondIds(int atomId) const
   {  return atomBondIdArrays_[atomId]; }
   #endif

   #ifdef SIMP_ANGLE
   /*
   * Get number of angles per molecule.
   */
   inline int Species::nAngle() const
   {  return nAngle_; }

   /*
   * Get a specific SpeciesAngle object by local index.
   */
   inline 
   const Species::SpeciesAngle& Species::speciesAngle(int iAngle) const
   {  return speciesAngles_[iAngle]; }

   /*
   * Get array of ids for angles that contain one Atom.
   */
   inline 
   const Species::AtomAngleIdArray& Species::atomAngleIds(int atomId) const
   {  return atomAngleIdArrays_[atomId]; }
   #endif

   #ifdef SIMP_DIHEDRAL
   /*
   * Get number of dihedrals per molecule
   */
   inline int Species::nDihedral() const
   {  return nDihedral_; }

   /*
   * Get a specific SpeciesDihedral object by local index.
   */
   inline 
   const Species::SpeciesDihedral& Species::speciesDihedral(int iDihedral) 
   const
   {  return speciesDihedrals_[iDihedral]; }

   /*
   * Get array of ids for dihedrals that contain one Atom.
   */
   inline 
   const Species::AtomDihedralIdArray& Species::atomDihedralIds(int atomId) 
   const
   {  return atomDihedralIdArrays_[atomId]; }
   #endif

   /*
   * Is this a mutable species?
   */
   inline bool Species::isMutable() const
   {  return (mutatorPtr_ != 0); }

   /*
   * Get associated mutator object.
   */
   inline McMd::SpeciesMutator& Species::mutator()
   {
      assert(mutatorPtr_);  
      return *mutatorPtr_; 
   }

} 
#endif