PolymerTmpl.h

#ifndef PSCF_POLYMER_TMPL_H
#define PSCF_POLYMER_TMPL_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/PolymerSpecies.h>    // base class
#include <util/param/ParamComposite.h>   // base class
 
#include <util/containers/Pair.h>        // member template
#include <util/containers/DArray.h>      // member template
 
#include <pscf/chem/Vertex.h>
#include <pscf/chem/PolymerType.h>
#include <pscf/chem/PolymerModel.h>
 
namespace Pscf
{
 
   class Edge;
   using namespace Util;

   template <class BT>
   class PolymerTmpl : public PolymerSpecies
   {
 
   public:
 
      // Public typename aliases

      using BlockT = BT;

      using PropagatorT = typename BT::PropagatorT;
 
      // Public member functions

      PolymerTmpl();

      ~PolymerTmpl();

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

      virtual void solve(double phiTot = 1.0);


      Edge& edge(int id) final;

      Edge const& edge(int id) const final;

      BT& block(int id);

      BT const& block(int id) const ;

      PropagatorT& propagator(int blockId, int directionId);

      PropagatorT const & propagator(int blockId, int directionId) const;

      PropagatorT& propagator(int id);

 
      // Inherited public members
 
      using PolymerSpecies::vertex;
      using PolymerSpecies::propagatorId;
      using PolymerSpecies::path;
      using PolymerSpecies::nBlock;
      using PolymerSpecies::nVertex;
      using PolymerSpecies::nPropagator;
      using PolymerSpecies::length;
      using PolymerSpecies::nBead;
      using PolymerSpecies::type;
 
      using Species::phi;
      using Species::mu;
      using Species::q;
      using Species::ensemble;
 
   protected:

      void allocateBlocks() final;

      void readBlocks(std::istream& in) final;
 
   private:

      DArray<BlockT> blocks_;

      void isValid();
 
   };
 
   // Inline functions
 
   /*
   * Get a specified Edge (block descriptor) by non-const reference.
   */
   template <class BT>
   inline
   Edge& PolymerTmpl<BT>::edge(int id)
   {  return blocks_[id]; }
 
   /*
   * Get a specified Edge (block descriptor) by const reference.
   */
   template <class BT>
   inline
   Edge const & PolymerTmpl<BT>::edge(int id) const
   {  return blocks_[id]; }
 
   /*
   * Get a specified Block solver by non-const reference.
   */
   template <class BT>
   inline
   BT& PolymerTmpl<BT>::block(int id)
   {  return blocks_[id]; }
 
   /*
   * Get a specified Block solver by const reference.
   */
   template <class BT>
   inline
   BT const & PolymerTmpl<BT>::block(int id) const
   {  return blocks_[id]; }
 
   /*
   * Get a propagator, indexed by block and direction ids (non-const).
   */
   template <class BT>
   inline
   typename BT::PropagatorT&
   PolymerTmpl<BT>::propagator(int blockId, int directionId)
   {  return block(blockId).propagator(directionId); }
 
   /*
   * Get a propagator, indexed by block and direction ids (const).
   */
   template <class BT>
   inline
   typename BT::PropagatorT const &
   PolymerTmpl<BT>::propagator(int blockId, int directionId) const
   {  return block(blockId).propagator(directionId); }
 
   /*
   * Get a propagator, indexed in order of computation.
   */
   template <class BT>
   inline
   typename BT::PropagatorT& PolymerTmpl<BT>::propagator(int id)
   {
      Pair<int> propId = propagatorId(id);
      return propagator(propId[0], propId[1]);
   }
 
}
#include "PolymerTmpl.tpp"
#endif