SpeciesEnsemble.h

#ifndef UTIL_SPECIES_ENSEMBLE_H
#define UTIL_SPECIES_ENSEMBLE_H

/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/param/ParamComposite.h>
#include <util/archives/serialize.h>
#include <util/global.h>

namespace Simp
{

   using namespace Util;

   class SpeciesEnsemble : public ParamComposite
   {

   public:

      enum Type{UNKNOWN, CLOSED, GRAND};

      SpeciesEnsemble(Type type = UNKNOWN);

      ~SpeciesEnsemble();

      void  setMu(double mu);

      virtual void readParam(std::istream& in);


      
      bool isClosed() const;

      bool isGrand() const;

      double mu() const;

      
      #ifdef UTIL_MPI

      static void commitMpiType();
      #endif

   private:

      double mu_;

      Type   type_;

   };

   std::istream& operator>>(std::istream& in, SpeciesEnsemble::Type &type);

   std::ostream& operator<<(std::ostream& out, const SpeciesEnsemble::Type &type);

   // Inline methods
 
   inline double SpeciesEnsemble::mu() const
   {  return mu_; }

   // Return true if this is an Closed ensemble.
   inline bool SpeciesEnsemble::isClosed() const
   { return (type_ == CLOSED); }
 
   // Return true if this is an Grand Ensemble.
   inline bool SpeciesEnsemble::isGrand() const
   { return (type_ == GRAND); }

   template <class Archive>
   inline void serialize(Archive& ar, SpeciesEnsemble::Type& data, const unsigned int version)
   {  serializeEnum(ar, data, version); }

}

#ifdef UTIL_MPI
#include <util/mpi/MpiTraits.h>
namespace Util
{

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

   template <>
   class MpiTraits<Simp::SpeciesEnsemble::Type>
   {  
   public:  
      static MPI::Datatype type;    
      static bool hasType;          
   };

}
#endif

#endif