pspg/solvers/Propagator.h

#ifndef PSPG_PROPAGATOR_H
#define PSPG_PROPAGATOR_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <pscf/solvers/PropagatorTmpl.h> // base class template
#include <pspg/field/RDField.h>          // member template
#include <util/containers/DArray.h>      // member template
 
namespace Pscf { template <int D> class Mesh; }
 
namespace Pscf { 
namespace Pspg
{ 
 
   template <int D> class Block;
   using namespace Util;
 
   template <int D>
   class Propagator : public PropagatorTmpl< Propagator<D> >
   {
 
   public:
 
      // Public typedefs
 
      typedef RDField<D> Field;
 
      typedef RDField<D> WField;
 
      typedef RDField<D> CField;
 
      typedef RDField<D> QField;
 
      // Member functions
 
      Propagator();
 
      ~Propagator();
 
      void setBlock(Block<D>& block);
 
      void allocate(int ns, const Mesh<D>& mesh);
 
      void solve();
  
      void solve(const cudaReal * head);
 
      double computeQ();
 
      const cudaReal* q(int i) const;
 
      cudaReal* head() const;
 
      const cudaReal* tail() const;
 
      Block<D>& block();
 
      Block<D> const & block() const;
 
      int ns() const;
 
      bool isAllocated() const;
 
      using PropagatorTmpl< Propagator<D> >::nSource;
      using PropagatorTmpl< Propagator<D> >::source;
      using PropagatorTmpl< Propagator<D> >::partner;
      using PropagatorTmpl< Propagator<D> >::setIsSolved;
      using PropagatorTmpl< Propagator<D> >::isSolved;
      using PropagatorTmpl< Propagator<D> >::hasPartner;
 
   protected:
 
      void computeHead();
 
   private:
 
      // new array purely in device
      cudaReal* qFields_d;
      // Workspace
      // removing this. Does not seem to be used anywhere
      //QField work_;
 
      Block<D>* blockPtr_;
 
      Mesh<D> const * meshPtr_;
 
      int ns_;
 
      bool isAllocated_;
 
      cudaReal* d_temp_;
      cudaReal* temp_;
 
   };
 
   // Inline member functions
 
   /*
   * Return q-field at beginning of block.
   */
   template <int D>
   inline 
   cudaReal* Propagator<D>::head() const
   {  return qFields_d; }
 
   /*
   * Return q-field at end of block, after solution.
   */
   template <int D>
   inline 
   const cudaReal* Propagator<D>::tail() const
   {  return qFields_d + ((ns_-1) * meshPtr_->size()); }
 
   /*
   * Return q-field at specified step.
   */
   template <int D>
   inline 
   const cudaReal* Propagator<D>::q(int i) const
   {  return qFields_d + (i * meshPtr_->size()); }
 
   /*
   * Get the associated Block object (non-const reference)
   */
   template <int D>
   inline 
   Block<D>& Propagator<D>::block()
   {
      assert(blockPtr_);  
      return *blockPtr_; 
   }
 
   /*
   * Get the associated Block object (non-const reference)
   */
   template <int D>
   inline 
   Block<D> const & Propagator<D>::block() const
   {
      assert(blockPtr_);  
      return *blockPtr_; 
   }
 
   /*
   * Get the number ns of contour grid points.
   */
   template <int D>
   inline 
   int Propagator<D>::ns() const
   {  return ns_; }
 
   template <int D>
   inline 
   bool Propagator<D>::isAllocated() const
   {  return isAllocated_; }
 
   /*
   * Associate this propagator with a block and direction
   */
   template <int D>
   inline 
   void Propagator<D>::setBlock(Block<D>& block)
   {  blockPtr_ = &block; }
 
 
   #ifndef PSPG_PROPAGATOR_TPP
   // Suppress implicit instantiation
   extern template class Propagator<1>;
   extern template class Propagator<2>;
   extern template class Propagator<3>;
   #endif
 
}
}
 
//#include "Propagator.tpp" 
#endif