mcMd/chemistry/Group.h

#ifndef MCMD_GROUP_H
#define MCMD_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.
*/

namespace McMd
{

   using namespace Util;

   class Atom;

   template <int NAtom>
   class Group
   {

   public: 

      Group();



      void setAtom(int i, Atom &atom);

      void setTypeId(int typeId);



      Atom& atom(int i);

      const Atom& atom(int i) const;

      int typeId() const;

      bool isActive() const;

      int nInActive() const;

      bool checkInactive() const;


   private:

      Atom* atoms_[NAtom];

      int typeId_;

      int nInActive_;

      // Private member functions, accessible by class Activate

      void activate();

      void incrementInactive();

      void decrementInactive();

   // friends:

      friend class Activate;

   };

   /*
   * Constructor 
   */
   template <int NAtom>
   Group<NAtom>::Group()
    : typeId_(-1),
      nInActive_(0)
   {
      for (int i=0; i < NAtom; ++i) {
         atoms_[i] = 0;
      }
   }

   /*
   * Add an atom to the group.
   */
   template <int NAtom>
   inline void Group<NAtom>::setAtom(int i, Atom &atom)
   {  atoms_[i] = &atom; }

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

   // Accessors

   /*
   * Get a specific Atom in the Group.
   */
   template <int NAtom>
   inline Atom& Group<NAtom>::atom(int i)
   {
      assert(atoms_[i]);  
      return *atoms_[i]; 
   }

   /*
   * Get a const reference to a specific Atom in the Group.
   */
   template <int NAtom>
   inline const Atom& Group<NAtom>::atom(int i) const
   {  
      assert(atoms_[i]);  
      return *atoms_[i]; 
   }

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

   /*
   * Is this group active?
   */
   template <int NAtom>
   inline bool Group<NAtom>::isActive() const
   {  return (nInActive_ == 0); }

   /*
   * Return number of inactive atoms.
   */
   template <int NAtom>
   inline int Group<NAtom>::nInActive() const
   {  return nInActive_; }

   /*
   * Check consistency of nInActive counter.
   */
   template <int NAtom>
   bool Group<NAtom>::checkInactive() const
   {
      int counter = 0;
      for (int i=0; i < NAtom;  ++i) {
         assert(atoms_[i]);  
         if (!atoms_[i]->isActive()) ++counter;
      }
      if (counter != nInActive_) {
         UTIL_THROW("Inconsistent number of inactive atoms");
      }
      return true;
   }

   // Private functions that modify nInActive_

   /*
   * Activate the group (set nInActive_ = 0)   
   */
   template <int NAtom>
   inline void Group<NAtom>::activate()
   {  nInActive_ = 0; }

   /*
   * Increment the number of inactive atoms.
   */
   template <int NAtom>
   inline void Group<NAtom>::incrementInactive()
   {  
      assert(nInActive_ < NAtom);  
      ++nInActive_; 
   }

   /*
   * Decrement the number of inactive atoms.
   */
   template <int NAtom>
   inline void Group<NAtom>::decrementInactive()
   {
      assert(nInActive_ > 0);
      --nInActive_;
   }

}
#endif