rpg/solvers/Propagator.h

#ifndef RPG_PROPAGATOR_H
#define RPG_PROPAGATOR_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 <rp/solvers/Propagator.h>   // base class template
#include <rpg/system/Types.h>        // base class template argument
#include <pscf/cuda/DeviceArray.h>   // member
 
namespace Pscf {
namespace Rpg {
 
   using namespace Util;
   using namespace Pscf::Prdc;

   template <int D>
   class Propagator : public Rp::Propagator< D, Types<D> >
   {
 
   public:
 
      // Member functions

      Propagator();

      ~Propagator();

      void allocate(int ns, const Mesh<D>& mesh) override;

      void reallocate(int ns) override;

      DeviceArray<cudaReal> const & qAll();
 
   protected:

      using RpPropagatorT = Rp::Propagator<D, Types<D> >;
 
      // Inherited typename alias
      using typename RpPropagatorT::PropagatorTmplT;
 
      using RpPropagatorT::qFields_;
      using RpPropagatorT::ns_;
      using RpPropagatorT::isAllocated_;
      using RpPropagatorT::computeHead;
 
   private:

      DeviceArray<cudaReal> qFieldsAll_;

      void dissociateQFields();
 
   };
 
   // Inline function
 
   /*
   * Return the full array of q-fields.
   */
   template <int D> inline
   DeviceArray<cudaReal> const & Propagator<D>::qAll()
   {
      UTIL_CHECK(PropagatorTmplT::isSolved());
      return qFieldsAll_;
   }
 
} // namespace Rpg
} // namespace Pscf
 
// Explicit instantiation declarations
namespace Pscf {
   namespace Rp {
      extern template class Propagator<1, Rpg::Types<1> >;
      extern template class Propagator<2, Rpg::Types<2> >;
      extern template class Propagator<3, Rpg::Types<3> >;
   }
   namespace Rpg {
      extern template class Propagator<1>;
      extern template class Propagator<2>;
      extern template class Propagator<3>;
   }
}
#endif