Edge.h

#ifndef PSCF_EDGE_H
#define PSCF_EDGE_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "PolymerType.h"
#include <util/containers/Pair.h>
 
#include <iostream>
 
namespace Pscf
{
 
   using namespace Util;
 
   class Edge
   {
   public:
 
      Edge();
 
      virtual ~Edge();
 
      template <class Archive>
      void serialize(Archive& ar, unsigned int versionId);
 
 
 
      void setId(int id);
 
      void setVertexIds(int vertexAId, int vertexBId);
 
      void setMonomerId(int monomerId);
 
      virtual void setLength(double length);
 
      void setPolymerType(PolymerType::Enum type);
 
 
 
      int id() const;
 
      int monomerId() const;
 
      const Pair<int>& vertexIds() const;
 
      int vertexId(int i) const;
 
      double length() const;
 
      PolymerType::Enum polymerType() const;
 
 
   private:
 
      int id_;
 
      int monomerId_;
 
      double length_;
 
      Pair<int> vertexIds_;
 
      PolymerType::Enum polymerType_;
 
      friend
      std::istream& operator >> (std::istream& in, Edge &block);
 
      friend
      std::ostream& operator << (std::ostream& out,
                                 const Edge &block);
 
   };
 
   std::istream& operator >> (std::istream& in, Edge &block);
 
   std::ostream&
   operator << (std::ostream& out, const Edge &block);
 
   // Inline member functions
 
   /*
   * Get the id of this block.
   */
   inline int Edge::id() const
   {  return id_; }
 
   /*
   * Get the monomer type id.
   */
   inline int Edge::monomerId() const
   {  return monomerId_; }
 
   /*
   * Get the pair of associated vertex ids.
   */
   inline const Pair<int>& Edge::vertexIds() const
   {  return vertexIds_; }
 
   /*
   * Get id of an associated vertex.
   */
   inline int Edge::vertexId(int i) const
   {  return vertexIds_[i]; }
 
   /*
   * Get the length (number of monomers) in this block.
   */
   inline double Edge::length() const
   {  return length_; }
 
   /*
   * Get the polymer type (branched or linear).
   */
   inline PolymerType::Enum Edge::polymerType() const
   {  return polymerType_; }
 
   /*
   * Serialize to/from an archive.
   */
   template <class Archive>
   void Edge::serialize(Archive& ar, unsigned int)
   {
      ar & id_;
      ar & monomerId_;
      ar & vertexIds_;
      ar & length_;
   }
 
}
#endif