SpeciesGroup.h

#ifndef SIMP_SPECIES_GROUP_H
#define SIMP_SPECIES_GROUP_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/global.h>

#include <iostream>

namespace Simp
{

   // Forward declarations of templates required for friend declarations.

   template <int NAtom> class SpeciesGroup;

   template <int NAtom> std::istream&
   operator >> (std::istream& in, SpeciesGroup<NAtom> &speciesGroup);

   template <int NAtom> std::ostream&
   operator << (std::ostream& out, const SpeciesGroup<NAtom>& speciesGroup);

   template <int NAtom> std::ostream&
   operator << (std::ostream& out, const SpeciesGroup<NAtom>& speciesGroup);

   template <class Archive, int NAtom>
   void serialize(Archive& ar, SpeciesGroup<NAtom>& speciesGroup,
                  const unsigned int version);

   template <int NAtom>
   class SpeciesGroup
   {

   public:

      static const int NullIndex = -1;

      SpeciesGroup();

      void setAtomId(int i, int atomId);

      void setTypeId(int typeId);

      int atomId(int i) const;

      int typeId() const;

      #ifdef UTIL_MPI

      static void commitMpiType();
      #endif

   private:

      int atomIds_[NAtom];

      int typeId_;

   //friends:

      friend
      std::istream&
      operator >> <> (std::istream& in, SpeciesGroup<NAtom>& speciesGroup);

      friend
      std::ostream&
      operator << <> (std::ostream& out, const SpeciesGroup<NAtom>& speciesGroup);

      template <class Archive> friend
      void serialize(Archive& ar, SpeciesGroup<NAtom>& speciesGroup,
                     const unsigned int version);

      template <class Archive> friend
      void serialize(Archive& ar, SpeciesGroup<NAtom>& speciesGroup,
                     const unsigned int version);

   };

   /*
   * Constructor.
   */
   template <int NAtom>
   inline SpeciesGroup<NAtom>::SpeciesGroup()
    : typeId_(NullIndex)
   {
      for (int i=0; i < NAtom; ++i) {
         atomIds_[i] = NullIndex;
      }
   }

   /*
   * Set index for one atom in the group.
   */
   template <int NAtom>
   inline void SpeciesGroup<NAtom>::setAtomId(int i, int atomId)
   {  atomIds_[i] = atomId; }

   /*
   * Set the group type id for this group.
   */
   template <int NAtom>
   inline void SpeciesGroup<NAtom>::setTypeId(int typeId)
   {  typeId_ = typeId; }

   /*
   * Get the local id for a specific Atom.
   */
   template <int NAtom>
   inline int SpeciesGroup<NAtom>::atomId(int i) const
   {  return atomIds_[i]; }

   /*
   * Get the type id for this covalent group.
   */
   template <int NAtom>
   inline int SpeciesGroup<NAtom>::typeId() const
   {  return typeId_; }

   // Inserter and extractor operator declarations

   template <int NAtom>
   std::istream&
   operator >> (std::istream& in, SpeciesGroup<NAtom> &speciesGroup);

   template <int NAtom>
   std::ostream&
   operator << (std::ostream& out, const SpeciesGroup<NAtom> &speciesGroup);

   // Serialize definitions

   template <class Archive>
   void serialize(Archive& ar, SpeciesGroup<2>& speciesGroup, const unsigned int version)
   {
      for (int i = 0; i < 2; ++i) {
         ar & speciesGroup.atomIds_[i];
      }
      ar & speciesGroup.typeId_;
   }

   template <class Archive>
   void serialize(Archive& ar, SpeciesGroup<3>& speciesGroup, const unsigned int version)
   {
      for (int i = 0; i < 3; ++i) {
         ar & speciesGroup.atomIds_[i];
      }
      ar & speciesGroup.typeId_;
   }

   template <class Archive>
   void serialize(Archive& ar, SpeciesGroup<4>& speciesGroup, const unsigned int version)
   {
      for (int i = 0; i < 4; ++i) {
         ar & speciesGroup.atomIds_[i];
      }
      ar & speciesGroup.typeId_;
   }

}

#ifdef UTIL_MPI
#include <util/mpi/MpiTraits.h>

namespace Util
{

   template <>
   class MpiTraits< Simp::SpeciesGroup<4> >
   {  
   public:  
      static MPI::Datatype type;   
      static bool hasType;         
   };

   template <>
   class MpiTraits< Simp::SpeciesGroup<3> >
   {  
   public:  
      static MPI::Datatype type;   
      static bool hasType;         
   };

   template <>
   class MpiTraits< Simp::SpeciesGroup<2> >
   {  
   public:  
      static MPI::Datatype type;   
      static bool hasType;         
   };

} 

namespace Simp
{

   void commitMpiSpeciesGroupTypes(); 

}
#endif  // ifdef UTIL_MPI

#endif