rpg/solvers/Polymer.h

#ifndef RPG_POLYMER_H
#define RPG_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 <rpg/solvers/Block.h>             // base class argument
 
//#include <prdc/cuda/RField.h>
#include <util/containers/FSArray.h> 
 
// Forward declarations
namespace Util {
   template <typename T> class DArray;
}
namespace Pscf { 
   namespace Prdc {
      template <int D> class UnitCell;
      namespace Cuda {
         template <int D> class WaveList;
         template <int D> class RField;
      }
   }
}
 
namespace Pscf { 
namespace Rpg { 
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cuda;

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

      using Base = PolymerTmpl< Block<D> >;

      using BlockT = Block<D>;

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

      Polymer();

      ~Polymer();
 
      void setNParams(int nParams);

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

      void computeStress();

      double stress(int n);
 
      // 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 nParams_;
 
      // Restrict access to inherited functions
      using Base::solve;
      using Species::setQ;
 
   };
 
   // Get stress component n.
   template <int D>
   double Polymer<D>::stress(int n)
   {  return stress_[n]; }
 
   #ifndef RPG_POLYMER_TPP
   // Suppress implicit instantiation
   extern template class Polymer<1>;
   extern template class Polymer<2>;
   extern template class Polymer<3>;
   #endif
 
}
}
#endif