ddMd/chemistry/Atom.h

#ifndef DDMD_ATOM_H
#define DDMD_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.
*/

//#define UTIL_32BIT

#include <util/space/Vector.h>            // members
#include <ddMd/chemistry/Mask.h>          // member
#include <ddMd/communicate/Plan.h>        // member 
#include "AtomArray.h"                    // inline methods

namespace Util{ class Memory; }

namespace DdMd
{

   class Buffer;
   using namespace Util;

   class Atom
   {

   public:

      // Static member functions
 
      static void setHasAtomContext(bool hasAtomContext);

      static bool hasAtomContext();
 
      #ifdef UTIL_MPI

      static int packedAtomSize();

      static int packedGhostSize();
      #endif

      // Non-static member functions
 


      Atom& operator = (Atom const & other);

      void clear();

      void setId(int Id);

      void setTypeId(int Id);

      void setIsGhost(bool isGhost);



      Vector& position();

      Vector& velocity();

      Vector& force();

      Mask& mask();

      Plan& plan();

      AtomContext& context();

      unsigned int& groups();

      #if 0

      IntVector& shift();
      #endif



      int id() const;

      int typeId() const;

      bool isGhost() const;

      const Vector& position() const;

      const Vector& velocity() const;

      const Vector& force() const;

      const Mask& mask() const;

      const Plan& plan() const;

      const AtomContext& context() const;

      unsigned int groups() const;

      #if 0

      const IntVector& shift() const;
      #endif




      #ifdef UTIL_MPI

      void packAtom(Buffer& buffer);

      void unpackAtom(Buffer& buffer);

      void packGhost(Buffer& buffer);

      void unpackGhost(Buffer& buffer);

      void packUpdate(Buffer& buffer);

      void unpackUpdate(Buffer& buffer);

      void packForce(Buffer& buffer);

      void unpackForce(Buffer& buffer);

      #endif // ifdef UTIL_MPI

      void copyLocalGhost(Atom const & sendAtom);

      void copyLocalUpdate(Atom const & sendAtom);


   private:

      static bool hasAtomContext_;

      Vector position_;

      int typeId_;

      unsigned int localId_;

      Vector force_;

      AtomArray* arrayPtr_;

      #ifdef UTIL_32BIT

      int pad_;
      #endif

      Atom();

      Atom(Atom const & other);

   // friends:
   
      friend class AtomArray;
      friend class Util::Memory;

   };

   // Inline methods

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

   /*
   * Set isGhost flag.
   */
   inline void Atom::setIsGhost(bool isGhost)
   {
      if (isGhost) {
         // Set least significant bit of localId_ to 1
         localId_ = localId_ | 1;
      } else {
         // Set least significant bit of localId_ to 0
         localId_ = localId_ & ~1;
      }
   }

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

   /*
   * Is this a ghost atom?
   */
   inline bool Atom::isGhost() const
   {
      // Return least significant bit of localId_
      return bool(localId_ & 1);
   }

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

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

   /*
   * Get force by reference.
   */
   inline Vector& Atom::force()
   {  return force_; }

   /*
   * Get force by const reference.
   */
   inline Vector const & Atom::force() const
   {  return force_; }

   /*
   * Accessors for pseudo-members stored in separate arrays.
   *
   * An atom can be constructed only as an element of a parent AtomArray
   * (see documentation for private default constructor). Some data owned
   * by an Atom is stored in a set of private array that are allocated by
   * its AtomArray. In each such array, the element associated with this 
   * Atom is indexed by the localId_ of this atom, without the least 
   * signficant bit (see documentation of the localId_ member). The bit 
   * shift operation "localId_ >> 1" in each of the following functions 
   * strips off the least signficant bit, which is used to store the isGhost 
   * flag, and returns the relevant array index. Each arrays that stores
   * pseudo-member data is a private member of the parent AtomArray (e.g.,
   * AtomArray::velocities_, AtomArray::masks_, etc.) that is accessible
   * because Atom is a friend class of AtomArray.
   */

   /* 
   * Get reference to velocity.
   */
   inline Vector& Atom::velocity()
   {  return arrayPtr_->velocities_[localId_ >> 1]; }

   /*
   * Get velocity by const reference.
   */
   inline Vector const & Atom::velocity() const
   { return arrayPtr_->velocities_[localId_ >> 1]; }

   /*
   * Get the Mask by reference.
   */
   inline Mask& Atom::mask()
   {  return arrayPtr_->masks_[localId_ >> 1]; }

   /*
   * Get the Mask by const reference.
   */
   inline Mask const & Atom::mask() const
   {  return arrayPtr_->masks_[localId_ >> 1]; }

   /*
   * Get the communication plan by reference.
   */
   inline Plan& Atom::plan()
   {  return arrayPtr_->plans_[localId_ >> 1]; }

   /*
   * Get the communication plan by const reference.
   */
   inline Plan const & Atom::plan() const
   {  return arrayPtr_->plans_[localId_ >> 1]; }

   /*
   * Get the global id for this Atom.
   */
   inline int  Atom::id() const
   {  return arrayPtr_->ids_[localId_ >> 1]; }

   /*
   * Set the global id for this Atom.
   */
   inline void Atom::setId(int id)
   {  arrayPtr_->ids_[localId_ >> 1] = id; }

   /* 
   * Get AtomContext by non-const reference.
   */
   inline AtomContext& Atom::context()
   {  
      if (!hasAtomContext_) {
         UTIL_THROW("Atom does not have AtomContext");
      }
      return arrayPtr_->contexts_[localId_ >> 1]; 
   }

   /*
   * Get AtomContext by const reference.
   */
   inline AtomContext const & Atom::context() const
   {
      if (!hasAtomContext_) {
         UTIL_THROW("Atom does not have AtomContext");
      }
      return arrayPtr_->contexts_[localId_ >> 1]; 
   }

   /* 
   * Get group bit map by non-const reference.
   */
   inline unsigned int& Atom::groups()
   {  return arrayPtr_->groups_[localId_ >> 1]; }

   /*
   * Get groups bit map by value.
   */
   inline unsigned int Atom::groups() const
   {  return arrayPtr_->groups_[localId_ >> 1]; }

   /*
   * Is AtomContext data enabled?
   */
   inline bool Atom::hasAtomContext()
   {  return hasAtomContext_; }
 
}
#endif