cpc/solvers/Block.h

#ifndef CPC_BLOCK_H
#define CPC_BLOCK_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/BlockTmpl.h>       // base class template
 
#include <prdc/cpu/CField.h>              // members
#include <prdc/cpu/RField.h>              // member
 
namespace Pscf {
 
   // Forward declarations
   template <int D> class Mesh;
   namespace Prdc{
      template <int D> class UnitCell;
      namespace Cpu {
         template <int D> class FFT;
         template <int D> class WaveList;
      }
   }
   namespace Cpc{
      template <int D> class Propagator;
   }
 
   // Explicit instantiation declarations for base class
   extern template
   class BlockTmpl< Cpc::Propagator<1>, Prdc::Cpu::CField<1> >;
   extern template
   class BlockTmpl< Cpc::Propagator<2>, Prdc::Cpu::CField<2> >;
   extern template
   class BlockTmpl< Cpc::Propagator<3>, Prdc::Cpu::CField<3> >;
 
}
 
namespace Pscf {
namespace Cpc {
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cpu;

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

      using Base = BlockTmpl< Propagator<D>, CField<D> >;

      using typename Base::PropagatorT;

      using typename Base::FieldT;
 
      // Public member functions

      Block();

      ~Block();

      void associate(Mesh<D> const& mesh,
                     FFT<D> const& fft,
                     UnitCell<D> const& cell,
                     WaveList<D>& wavelist);

      void allocate(double ds);

      void clearUnitCellData();

      void setLength(double newLength);

      void setKuhn(double kuhn);

      void setupSolver(CField<D> const & w);

      void stepThread(CField<D> const & qin, CField<D>& qout) const;

      void stepBead(CField<D> const & qin, CField<D>& qout) const;

      void stepFieldBead(CField<D> & q) const;

      void stepBondBead(CField<D> const & qin, CField<D>& qout) const;

      void stepHalfBondBead(CField<D> const & qin, CField<D>& qout) const;

      void computeConcentrationThread(fftw_complex const & prefactor);

      void computeConcentrationBead(fftw_complex const & prefactor);

      double ds() const;

      int ns() const;
 
      // Inherited public member functions with non-dependent names
 
      using Base::setKuhn;
      using Base::propagator;
      using Base::cField;
      using Base::kuhn;
 
      using Edge::setId;
      using Edge::setVertexIds;
      using Edge::setMonomerId;
      using Edge::setLength;
      using Edge::id;
      using Edge::monomerId;
      using Edge::vertexIds;
      using Edge::vertexId;
      using Edge::length;
      using Edge::nBead;
 
   private:
 
      // Private member data
 
      // In bead model, ds=1 by definition.

      RField<D> expKsq_;

      RField<D> expKsq2_;

      CField<D> expW_;

      CField<D> expW2_;

      CField<D> expWInv_;

      mutable CField<D> qr_;

      mutable CField<D> qr2_;

      mutable CField<D> qk_;

      mutable CField<D> qk2_;

      Mesh<D> const * meshPtr_;

      FFT<D> const * fftPtr_;

      UnitCell<D> const * unitCellPtr_;

      WaveList<D> * waveListPtr_;

      double ds_;

      double dsTarget_;

      int ns_;

      bool isAllocated_;

      bool hasExpKsq_;

      int nParams_;
 
      // Private member functions

      Mesh<D> const & mesh() const;

      UnitCell<D> const & unitCell() const;

      FFT<D> const & fft() const;

      WaveList<D> const & wavelist() const;

      void computeExpKsq();
 
   };
 
   // Public inline member functions
 
   // Get number of contour grid points, including end points.
   template <int D>
   inline int Block<D>::ns() const
   {  return ns_; }
 
   // Get contour step size.
   template <int D>
   inline double Block<D>::ds() const
   {  return ds_; }
 
   // Private inline member functions
 
   // Get associated Mesh<D> by const reference.
   template <int D> inline
   Mesh<D> const & Block<D>::mesh() const
   {
      UTIL_CHECK(meshPtr_);
      return *meshPtr_;
   }
 
   // Get associated UnitCell<D> as const reference.
   template <int D> inline
   UnitCell<D> const & Block<D>::unitCell() const
   {  return *unitCellPtr_; }
 
   // Get associated FFT<D> by const reference.
   template <int D> inline
   FFT<D> const & Block<D>::fft() const
   {
      UTIL_CHECK(fftPtr_);
      return * fftPtr_;
   }
 
   // Get associated WaveList<D> by const reference.
   template <int D> inline
   WaveList<D> const & Block<D>::wavelist() const
   {  return *waveListPtr_; }
 
   // Explicit instantiation declarations
   extern template class Block<1>;
   extern template class Block<2>;
   extern template class Block<3>;
 
} // Cpc
} // Pscf
#endif