PolymerSpecies.h

#ifndef PSCF_POLYMER_SPECIES_H
#define PSCF_POLYMER_SPECIES_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 <pscf/chem/Species.h>           // base class
#include <util/param/ParamComposite.h>   // base class
 
#include <pscf/chem/Vertex.h>            // member 
#include <pscf/chem/PolymerType.h>       // member
#include <util/containers/Pair.h>        // member 
#include <util/containers/DArray.h>      // member 
 
namespace Pscf
{
 
   // Forward declaration
   class Edge;
 
   using namespace Util;
 
   class PolymerSpecies : public Species, public ParamComposite
   {
 
   public:
 
      PolymerSpecies();
 
      ~PolymerSpecies();
 
      virtual void readParameters(std::istream& in);
 
 
      virtual Edge& edge(int id) = 0;
 
      virtual Edge const& edge(int id) const = 0;
 
      const Vertex& vertex(int id) const;
 
      Pair<int> const & propagatorId(int id) const;
 
      Pair<int> const & path(int is, int it) const;
 
 
      int nBlock() const;
 
      int nVertex() const;
 
      int nPropagator() const;  //
 
      double length() const;
 
      PolymerType::Enum type() const;
 
 
   protected:
 
      virtual void allocateBlocks() = 0;
 
      virtual void readBlocks(std::istream& in) = 0;
 
      virtual void makePlan();
 
      void makePaths();
 
      void isValid();
 
   private:
 
      DArray<Vertex> vertices_;
 
      DArray< Pair<int> > propagatorIds_;
 
      DArray< DArray< Pair<int> > > paths_;
 
      int nBlock_;
 
      int nVertex_;
 
      int nPropagator_;
 
      PolymerType::Enum type_;
 
   };
 
   /*
   * Number of vertices (ends and/or junctions)
   */
   inline int PolymerSpecies::nVertex() const
   {  return nVertex_; }
 
   /*
   * Number of blocks in this polymer.
   */
   inline int PolymerSpecies::nBlock() const
   {  return nBlock_; }
 
   /*
   * Number of propagators in this polymer.
   */
   inline int PolymerSpecies::nPropagator() const
   {  return nPropagator_; }
 
   /*
   * Get a specified Vertex by const reference.
   */
   inline
   Vertex const & PolymerSpecies::vertex(int id) const
   {  return vertices_[id]; }
 
   /*
   * Get a propagator id, indexed in order of computation (const).
   */
   inline
   Pair<int> const & PolymerSpecies::propagatorId(int id) const
   {
      UTIL_CHECK(id >= 0);
      UTIL_CHECK(id < nPropagator_);
      return propagatorIds_[id];
   }
 
   /*
   * Get a propagator id that leads from a source vertex towards a target.
   */
   inline
   Pair<int> const & PolymerSpecies::path(int is, int it) const
   {
      UTIL_CHECK(is >= 0);
      UTIL_CHECK(is < nVertex_);
      UTIL_CHECK(it >= 0);
      UTIL_CHECK(it < nVertex_);
      return paths_[is][it];
   }
 
   /*
   * Get the polymer type enumeration value (Branched or Linear).
   */
   inline 
   PolymerType::Enum PolymerSpecies::type() const
   {  return type_; }
 
}
#endif