LinkMaster.h

#ifdef  MCMD_LINK
#ifndef MCMD_LINK_MASTER_H
#define MCMD_LINK_MASTER_H

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, Veronica Chappa and The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include "Link.h" 
#include "LinkEvents.h" 
#include <mcMd/chemistry/Atom.h> 
#include <util/param/ParamComposite.h> 
#include <util/containers/DArray.h> 
#include <util/containers/ArrayStack.h> 
#include <util/containers/ArraySet.h> 
#include <util/containers/SSet.h> 
#include <util/containers/PArrayIterator.h> 
#include <util/containers/ConstPArrayIterator.h> 
#include <util/misc/Notifier.h> 


namespace Util
{  class Random; }

namespace McMd
{

   using namespace Util;

   class LinkMaster : public ParamComposite, 
                      public Notifier<LinkAddEvent>,
                      public Notifier<LinkResetEvent>,                      
                      public Notifier<LinkRemoveEvent>,
                      public Notifier<ReSetAtomEvent>                     
   {

   public:

      typedef PArrayIterator<Link>      LinkIterator;

      typedef ConstPArrayIterator<Link> ConstLinkIterator;

      typedef SSet<Link,400> AtomLinkSet;

      LinkMaster();

      // Use default destructor.

      void readParameters(std::istream& in);

      void addLink(Atom& atom0, Atom& atom1, int typeId);

      void removeLink(int id);


      const AtomLinkSet& atomLinkSet(const Atom& atom) const;

      AtomLinkSet& atomLinkSet(const Atom& atom);

      Link& link(int id) const;
          
      void reSetAtoms(Link& link, Atom& atom0, Atom& atom1);
      
      void reSetAtom(Link& link, Atom& atom, int endId);            
            
      int nLink() const;

      void begin(LinkIterator& iterator);

      void begin(ConstLinkIterator& iterator) const;

      Link& randomLink(Random& random);

      bool isValid() const;

      void clear();

   private:

      DArray<Link>     links_;

      ArraySet<Link>   linkSet_;

      ArrayStack<Link> reservoir_;

      DArray<AtomLinkSet>      atomLinkSets_;

      int linkCapacity_;

      int atomCapacity_;

      void allocate();

   };

   // Inline methods

   /*
   * Get the set of Links associated with an Atom by constant reference.
   */ 
   inline 
   const LinkMaster::AtomLinkSet& LinkMaster::atomLinkSet(const Atom& atom) const  
   {  
      return (atomLinkSets_[atom.id()]); 
   }

   /*
   * Get the set of Links associated with an Atom.
   */ 
   inline 
   LinkMaster::AtomLinkSet& LinkMaster::atomLinkSet(const Atom& atom)
   {  
      return (atomLinkSets_[atom.id()]); 
   }

   /*
   * Initialize iterator to beginning of list of active links.
   */
   inline void LinkMaster::begin(LinkMaster::LinkIterator& iterator)
   {   linkSet_.begin(iterator); }

   inline void LinkMaster::begin(LinkMaster::ConstLinkIterator& iterator) const
   {   linkSet_.begin(iterator); }

   /*
   * Get an active Link by index.
   */ 
   inline Link& LinkMaster::link(int id) const
   {  return linkSet_[id]; }

   /*
   * Get number of active Links.
   */ 
   inline int LinkMaster::nLink() const
   {  return linkSet_.size(); }

} 
#endif
#endif