PolymerSpecies.h

#ifndef PSCF_POLYMER_SPECIES_H
#define PSCF_POLYMER_SPECIES_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, 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 <pscf/chem/Vertex.h>            // member
#include <pscf/chem/PolymerType.h>       // member
#include <pscf/chem/PolymerModel.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:

      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;


      int nBlock() const;

      int nVertex() const;

      int nPropagator() const;  //

      double length() const;

      int nBead() const;

      PolymerType::Enum type() const;


      Pair<int> const & propagatorId(int id) const;

      Pair<int> const & path(int is, int it) const;

 
   protected:

      virtual void allocateBlocks() = 0;

      virtual void readBlocks(std::istream& in) = 0;

      virtual void makePlan();

      void makePaths();
 
   private:

      DArray<Vertex> vertices_;

      DArray< Pair<int> > propagatorIds_;

      DArray< DArray< Pair<int> > > paths_;

      int nBlock_;

      int nVertex_;

      int nPropagator_;

      PolymerType::Enum type_;

      void isValid();
 
   };
 
   // Inline functions
 
   /*
   * Number of blocks in this polymer.
   */
   inline int PolymerSpecies::nBlock() const
   {  return nBlock_; }
 
   /*
   * Number of vertices (ends and/or junctions)
   */
   inline int PolymerSpecies::nVertex() const
   {  return nVertex_; }
 
   /*
   * Number of propagators in this polymer (2*nBlock).
   */
   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.
   */
   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