tools/chemistry/Species.h

#ifndef TOOLS_SPECIES_H
#define TOOLS_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 "Molecule.h"
#include <util/containers/DArray.h>
#include <util/containers/DSArray.h>
#include <util/containers/ArrayIterator.h>

namespace Tools
{

   struct Atom;
   using namespace Util;

   class Species {
   public:
   
      typedef ArrayIterator<Molecule> Iterator;

      Species();
  
      ~Species();
  
      void setId(int id);
   
      void initialize(int nAtom, int capacity);
  
      void addAtom(Atom& atom);

      void clear();
  
      void begin(Iterator& iterator);
  
      Molecule& molecule(int i);
  
      int id() const;
  
      int nAtom() const;
  
      int size() const;
   
      int capacity() const;
 
      bool isValid() const;

      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
   
   private:

      DArray<Atom*> atomPtrs_;

      DSArray<Molecule> molecules_;
  
      int id_;
   
      int nAtom_;
  
      int capacity_;
   
      void initialize();
   
   //friends:
   
      friend 
      std::istream& operator >> (std::istream& in, Species& species);

      friend 
      std::ostream& operator << (std::ostream& out, const Species& species);
   
   };

   std::istream& operator>>(std::istream& in, Species &species);

   std::ostream& operator << (std::ostream& out, const Species &species);

   // Inline function definitions

   /*
   * Return a specific molecule. 
   */
   inline Molecule& Species::molecule(int i)
   {  return molecules_[i]; }

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

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

   /* 
   * Return the number of molecules (maximum molecule id + 1).
   */
   inline int Species::size() const
   {  return molecules_.size(); }

   /* 
   * Return the maximum number of molecules (memory capacity).
   */
   inline int Species::capacity() const
   {  return capacity_; }
 
   /*
   * Serialize to/from an archive.
   */
   template <class Archive>
   void Species::serialize(Archive& ar, const unsigned int version)
   {
      ar & nAtom_;
      ar & capacity_;
      if (Archive::is_loading()) {
         initialize();
      }
   }

}
#endif