mcMd/chemistry/AtomType.h

#ifndef MCMD_ATOM_TYPE_H
#define MCMD_ATOM_TYPE_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 <util/global.h>

#include <string>
#include <iostream>

namespace McMd
{

   using namespace Util;

   class AtomType
   {

   public:

      AtomType();

      virtual ~AtomType();



      void setId(int Id);

      void setName(std::string name);

      void setMass(double mass);

      #ifdef SIMP_COULOMB

      void setHasCharge(bool hasCharge);

      void setCharge(double charge);
      #endif



      double mass() const;

      #ifdef SIMP_COULOMB

      bool hasCharge() const;

      double charge() const;
      #endif

      const std::string& name() const;

      int id() const;


   private:

      double  mass_;

      #ifdef SIMP_COULOMB
      double  charge_;
      #endif

      std::string  name_;

      int  id_;

      bool hasCharge_;

   //friends:

      friend 
      std::istream& operator>>(std::istream& in, AtomType &atomType);

      friend 
      std::ostream& operator<<(std::ostream& out, const AtomType &atomType);

      template <class Archive> 
      friend void 
      serialize(Archive& ar, AtomType& atomType, const unsigned int version);

   };

   // Inline member functions.

   /*
   * Get the type id.
   */
   inline int  AtomType::id() const
   {  return id_; }

   /*
   * Get the name string.
   */
   inline const std::string& AtomType::name() const
   {  return name_; }

   /*
   * Get the mass.
   */
   inline double AtomType::mass() const
   {  return mass_; }

   #ifdef SIMP_COULOMB
   /*
   * Get the hasCharge bool flag.
   */
   inline bool AtomType::hasCharge() const
   {  return hasCharge_; }

   /*
   * Get the electrical charge.
   */
   inline double AtomType::charge() const
   {
      UTIL_ASSERT(hasCharge_);  
      return charge_; 
   }
   #endif

   // Declarations of friend extracter and inserter functions

   std::istream& operator>>(std::istream& in, AtomType &atomType);

   std::ostream& operator<<(std::ostream& out, const AtomType &atomType);

   template <class Archive>
   void serialize(Archive& ar, AtomType& atomType, const unsigned int version)
   {
      ar & atomType.name_;
      ar & atomType.mass_;
      #ifdef SIMP_COULOMB
      ar & atomType.hasCharge_;
      if (atomType.hasCharge_) {
         ar & atomType.charge_;
      }
      #endif
   }

}

#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#include <util/mpi/MpiTraits.h>

namespace Util
{

   template <>
   void send<McMd::AtomType>(MPI::Comm& comm, McMd::AtomType& data, int dest, int tag);

   template <>
   void recv<McMd::AtomType>(MPI::Comm& comm, McMd::AtomType& data, int source, int tag);

   template <>
   void bcast<McMd::AtomType>(MPI::Intracomm& comm, McMd::AtomType& data, int root);

   template <>
   class MpiTraits<McMd::AtomType>
   {
   public:
      static MPI::Datatype type;   
      static bool hasType;         
   };

}
#endif

#endif