rpg/solvers/Propagator.h

#ifndef RPG_PROPAGATOR_H
#define RPG_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 <prdc/cuda/RField.h>            // member array
#include <pscf/cuda/DeviceArray.h>       // member array
#include <pscf/solvers/PropagatorTmpl.h> // base class template
#include <util/containers/DArray.h>      // member array
 
namespace Pscf { 
 
   // Forward declaration
   template <int D> class Mesh;
 
namespace Rpg { 
 
   // Forward declaration
   template <int D> class Block;
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cuda;
 
   template <int D>
   class Propagator : public PropagatorTmpl< Propagator<D> >
   {
 
   public:
 
      // Public typedefs (used by template classes)
 
      typedef RField<D> Field;
 
      typedef RField<D> WField;
 
      typedef RField<D> CField;
 
      typedef RField<D> QField;
 
      // Member functions
 
      Propagator();
 
      ~Propagator();
 
      void setBlock(Block<D>& block);
 
      void allocate(int ns, const Mesh<D>& mesh);
 
      void reallocate(int ns);
 
      void solve();
  
      void solve(RField<D> const & head);
 
      double computeQ();
      
      RField<D> const & q(int i) const;
 
      RField<D> const & head();
 
      RField<D> const & tail() const;
 
      DeviceArray<cudaReal> const & qAll();
 
      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:
 
      DeviceArray<cudaReal> qFieldsAll_;
 
      DArray<RField<D> > qFields_;
 
      Block<D>* blockPtr_;
 
      Mesh<D> const * meshPtr_;
 
      int ns_;
 
      bool isAllocated_;
 
   };
 
   // Inline member functions
 
   /*
   * Return q-field at beginning of block.
   */
   template <int D>
   inline 
   RField<D> const & Propagator<D>::head()
   {  
      UTIL_CHECK(isAllocated());
      return qFields_[0];
   }
 
   /*
   * Return q-field at end of block, after solution.
   */
   template <int D>
   inline 
   RField<D> const & Propagator<D>::tail() const
   {  
      UTIL_CHECK(isSolved());
      return qFields_[ns_-1];
   }
 
   /*
   * Return const q-field at specified step by reference.
   */
   template <int D>
   inline 
   RField<D> const & Propagator<D>::q(int i) const
   {  
      UTIL_CHECK(isSolved());
      return qFields_[i];
   }
 
   /*
   * Return the full array of q-fields.
   */
   template <int D>
   inline 
   DeviceArray<cudaReal> const & Propagator<D>::qAll()
   {  
      UTIL_CHECK(isSolved());
      return qFieldsAll_;
   }
 
   /*
   * 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 chain contour 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 RPG_PROPAGATOR_TPP
   // Suppress implicit instantiation
   extern template class Propagator<1>;
   extern template class Propagator<2>;
   extern template class Propagator<3>;
   #endif
 
}
}
#endif