fd1d/solvers/Propagator.h

#ifndef FD1D_PROPAGATOR_H
#define FD1D_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 <util/containers/DArray.h>      // member template
 
namespace Pscf { 
namespace Fd1d
{ 
 
   class Block;
   using namespace Util;
 
   class Propagator : public PropagatorTmpl<Propagator>
   {
 
   public:
 
      // Public typedefs
 
      typedef DArray<double> Field;
 
      typedef DArray<double> WField;
 
      typedef DArray<double> CField;
 
      typedef DArray<double> QField;
 
      // Member functions
 
      Propagator();
 
      ~Propagator();
 
      void setBlock(Block& block);
 
      void allocate(int ns, int nx);
 
      void reallocate(int ns);
 
      void solve();
  
      void solve(const QField& head);
 
      double computeQ();
 
      QField const & q(int i) const;
 
      QField const & head() const;
 
      QField const & tail() const;
      
      int ns() const;
 
      bool isAllocated() const;
 
   private:
     
      DArray<QField> qFields_;
 
      QField work_;
 
      Block* blockPtr_;
 
      int ns_;
 
      int nx_;
 
      bool isAllocated_;
 
      Block & block();
 
      void computeHead();
 
   };
 
   // Inline member functions
 
   /*
   * Return q-field at beginning of block.
   */
   inline Propagator::QField const& Propagator::head() const
   {  return qFields_[0]; }
 
   /*
   * Return q-field at end of block, after solution.
   */
   inline Propagator::QField const& Propagator::tail() const
   {  return qFields_[ns_-1]; }
 
   /*
   * Return q-field at specified step.
   */
   inline Propagator::QField const& Propagator::q(int i) const
   {  return qFields_[i]; }
 
   /*
   * Get the associated Block object.
   */
   inline Block& Propagator::block()
   {
      assert(blockPtr_);  
      return *blockPtr_; 
   }
   
   /*
   * Get the number of counter grid points.
   */
   inline int Propagator::ns() const
   {  return ns_; }
 
   /*
   * Associate this propagator with a block and direction
   */
   inline void Propagator::setBlock(Block& block)
   {  blockPtr_ = &block; }
 
}
} 
#endif