rpc/solvers/Polymer.h

#ifndef RPC_POLYMER_H
#define RPC_POLYMER_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/solvers/PolymerTmpl.h>    // base class template
#include <util/containers/FSArray.h>     // member template
 
// Forward declarations
namespace Util {
   template <typename T> class DArray;
}
namespace Pscf { 
   namespace Rpc {
      template <int D> class Block;
      template <int D> class Propagator;
   }
   namespace Prdc { 
      namespace Cpu { 
         template <int D> class RField;
      }
   }
   extern template class PolymerTmpl< Rpc::Block<1>, Rpc::Propagator<1> >;
   extern template class PolymerTmpl< Rpc::Block<2>, Rpc::Propagator<2> >;
   extern template class PolymerTmpl< Rpc::Block<3>, Rpc::Propagator<3> >;
}
 
namespace Pscf { 
namespace Rpc { 
 
   using namespace Prdc;
   using namespace Pscf::Prdc::Cpu;

   template <int D>
   class Polymer : public PolymerTmpl< Block<D>, Propagator<D> >
   {
 
   public:
 
      // Public type name aliases

      using Base = PolymerTmpl< Block<D>, Propagator<D> >;

      using BlockT = Block<D>;

      using PropagatorT = Propagator<D>;
 
      // Public member functions

      Polymer();

      ~Polymer();

      void setNParams(int nParam);
 
      void clearUnitCellData();
 
      void compute(DArray< RField<D> > const & wFields, 
                   double phiTot = 1.0);

      void computeStress();

      double stress(int n) const;
 
      // Inherited public member functions
      
      using Base::edge;
      using Base::block;
      using Base::propagator;
      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;
      using Species::setPhi;
      using Species::setMu;
 
   private: 

      FSArray<double, 6> stress_;

      int nParam_;
 
      // Restricting access to inherited functions
      using Base::solve;
      using Species::setQ;
 
   };

   template <int D>
   inline double Polymer<D>::stress(int n) const
   {  return stress_[n]; }
  
   // Explicit instantiation declarations
   extern template class Polymer<1>;
   extern template class Polymer<2>;
   extern template class Polymer<3>;
 
}
}
#endif