mcMd/chemistry/Atom.h

#ifndef MCMD_ATOM_H
#define MCMD_ATOM_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 "Mask.h"
#include <util/space/Vector.h>
#ifdef MCMD_SHIFT
#include <util/space/IntVector.h>
#endif
#include <util/global.h>

namespace Util {
   template <class Data> class RArray;
}

namespace McMd
{

   using namespace Util;

   class Molecule;

   class Atom
   {

   public:

      // Non-static Methods

      // Private default and copy constructors.

      // Default destructor.
      


      void setMolecule(Molecule& molecule);

      void setTypeId(int typeId);



      int   id() const;

      int   indexInMolecule() const;

      int   typeId() const;

      Molecule& molecule() const;

      const Vector& position() const;

      Vector& position();

      Mask& mask();

      const Mask& mask() const;

      Vector& velocity();

      const Vector& velocity() const;

      Vector& force();

      const Vector& force() const;

      bool isActive() const;

      #ifdef MCMD_SHIFT
      IntVector& shift();

      const IntVector& shift() const;
      #endif



      static void initStatic();
     
      static void allocate(int capacity, RArray<Atom>& atoms);

      static void deallocate();

      static int capacity();


   private:

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

      static Atom* atoms_;

      static Mask* masks_;

      static Molecule** moleculePtrs_;

      static Vector* forces_;

      static Vector* velocities_;

      static bool* isActives_;

      #ifdef MCMD_SHIFT
      static IntVector* shifts_;
      #endif

      static int capacity_;

      // Non-static member variables
 
      Vector position_;                           

      int typeId_;                         

      int id_;                                   

      // Private non-static member functions

      Atom();

      Atom(const Atom& other);

      void setIsActive(bool isActive);

   // friends:

      friend class Activate;

   }; 

   // Inline pubic member functions

   // Set type index for Atom.
   inline void Atom:: setTypeId(int typeId) 
   {  typeId_ = typeId; }

   // Get global id for Atom.
   inline int  Atom::id() const
   {  return id_; }

   // Get type Id.
   inline int Atom::typeId() const
   {  return typeId_; }

   // Get const reference to position.
   inline const Vector& Atom::position() const
   {  return position_; }

   // Get reference to position.
   inline Vector& Atom::position()
   {  return position_; }

   // Get const reference to velocity.
   inline const Vector& Atom::velocity() const
   {  return velocities_[id_]; }

   // Get reference to velocity.
   inline Vector& Atom::velocity()
   {  return velocities_[id_]; }

   // Get const reference to force.
   inline const Vector& Atom::force() const
   {  return forces_[id_]; }

   // Get reference to force.
   inline Vector& Atom::force()
   {  return forces_[id_]; }

   // Get the associated mask.
   inline Mask& Atom::mask()
   {  return masks_[id_]; }

   // Get a const reference to the mask.
   inline const Mask& Atom::mask() const
   {  return masks_[id_]; }

   // Get a reference to the parent Molecule.
   inline Molecule& Atom::molecule() const
   {  return *moleculePtrs_[id_]; }

   // Get the isActive flag (true == active).
   inline bool Atom::isActive() const
   {  return isActives_[id_]; }

   #ifdef MCMD_SHIFT
   // Get the shift IntVector by reference.
   inline IntVector& Atom::shift()
   {  return shifts_[id_]; }

   // Get the shift IntVector by const reference.
   inline const IntVector& Atom::shift() const
   {  return shifts_[id_]; }
   #endif

   // Inline private member functions

   // Set the atom as active (true) or inactive (false) (private)
   inline void Atom::setIsActive(bool isActive)
   {  isActives_[id_] = isActive; }

}
#endif