rpc/solvers/Propagator.h

#ifndef RPC_PROPAGATOR_H
#define RPC_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/cpu/RField.h>             // member template
#include <pscf/solvers/PropagatorTmpl.h> // base class template
#include <util/containers/DArray.h>      // member template
#include <util/containers/FArray.h>      // member template
 
namespace Pscf { template <int D> class Mesh; }
 
namespace Pscf { 
namespace Rpc { 
 
   template <int D> class Block;
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cpu;
 
   template <int D>
   class Propagator : public PropagatorTmpl< Propagator<D> >
   {
 
   public:
 
      // Public typedefs
 
      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(QField const & head);
 
      double computeQ();
 
      const QField& q(int i) const;
 
      const QField& head() const;
 
      const QField& tail() const;
 
      Block<D>& block();
 
      int ns() const;
 
      bool isAllocated() const;
 
      // Inherited public members with non-dependent names
 
      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:
     
      DArray<QField> qFields_;
 
      QField work_;
 
      Block<D>* blockPtr_;
 
      Mesh<D> const * meshPtr_;
 
      int ns_;
 
      bool isAllocated_;
 
   };
   class Propagator : public PropagatorTmpl< Propagator<D> > {…};
 
   // Inline member functions
 
   /*
   * Return q-field at beginning of block.
   */
   template <int D>
   inline 
   typename Propagator<D>::QField const& Propagator<D>::head() const
   {  return qFields_[0]; }
   typename Propagator<D>::QField const& Propagator<D>::head() const {…}
 
   /*
   * Return q-field at end of block, after solution.
   */
   template <int D>
   inline 
   typename Propagator<D>::QField const& Propagator<D>::tail() const
   {  return qFields_[ns_-1]; }
   typename Propagator<D>::QField const& Propagator<D>::tail() const {…}
 
   /*
   * Return q-field at specified step.
   */
   template <int D>
   inline 
   typename Propagator<D>::QField const& Propagator<D>::q(int i) const
   {  return qFields_[i]; }
   typename Propagator<D>::QField const& Propagator<D>::q(int i) const {…}
 
   /*
   * Get the associated Block object.
   */
   template <int D>
   inline 
   Block<D>& Propagator<D>::block()
   {
      assert(blockPtr_);  
      return *blockPtr_; 
   }
   Block<D>& Propagator<D>::block() {…}
 
   /*
   * Get the number of counter grid points.
   */
   template <int D>
   inline int Propagator<D>::ns() const
   {  return ns_; }
   inline int Propagator<D>::ns() const {…}
 
   template <int D>
   inline bool Propagator<D>::isAllocated() const
   {  return isAllocated_; }
   inline bool Propagator<D>::isAllocated() const {…}
 
   /*
   * Associate this propagator with a unique block.
   */
   template <int D>
   inline void Propagator<D>::setBlock(Block<D>& block)
   {  blockPtr_ = &block; }
   inline void Propagator<D>::setBlock(Block<D>& block) {…}
 
   #ifndef RPC_PROPAGATOR_TPP
   extern template class Propagator<1>;
   extern template class Propagator<2>;
   extern template class Propagator<3>;
   #endif
 
}
}
#endif