PropagatorTmpl.h

#ifndef PSCF_PROPAGATOR_TMPL_H
#define PSCF_PROPAGATOR_TMPL_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 <util/containers/GArray.h>
 
namespace Pscf
{ 
 
   using namespace Util;
 
   template <class TP>
   class PropagatorTmpl
   {
 
   public:
 
      PropagatorTmpl();
 
 
      void setDirectionId(int directionId);
 
      void setPartner(const TP& partner);
 
      void addSource(const TP& source);
 
      void setIsSolved(bool isSolved);
 
 
      const TP& source(int id) const;
 
      const TP& partner() const;
 
      int directionId() const;
 
      int nSource() const;
 
      bool hasPartner() const;
 
      bool isSolved() const;
 
      bool isReady() const;
 
 
   private:
  
      int directionId_;
 
      TP const * partnerPtr_;
 
      GArray<TP const *> sourcePtrs_;
 
      bool isSolved_;
  
   };
 
   // Inline member functions
 
   /*
   * Get the direction index.
   */
   template <class TP>
   inline int PropagatorTmpl<TP>::directionId() const
   {  return directionId_; }
 
   /*
   * Get the number of source propagators.
   */
   template <class TP>
   inline int PropagatorTmpl<TP>::nSource() const
   {  return sourcePtrs_.size(); }
 
   /*
   * Get a source propagator.
   */
   template <class TP>
   inline const TP& 
   PropagatorTmpl<TP>::source(int id) const
   {  return *(sourcePtrs_[id]); }
 
   template <class TP>
   inline
   bool PropagatorTmpl<TP>::hasPartner() const
   {  return partnerPtr_; }
 
   /*
   * Is the computation of this propagator completed?
   */
   template <class TP>
   inline bool PropagatorTmpl<TP>::isSolved() const
   {  return isSolved_; }
 
   // Noninline member functions
 
   /*
   * Constructor.
   */
   template <class TP>
   PropagatorTmpl<TP>::PropagatorTmpl()
    : directionId_(-1),
      partnerPtr_(0),
      sourcePtrs_(),
      isSolved_(false)
   {}
 
   /*
   * Set the directionId.
   */
   template <class TP>
   void PropagatorTmpl<TP>::setDirectionId(int directionId)
   {  directionId_ = directionId; }
 
   /*
   * Set the partner propagator.
   */
   template <class TP>
   void PropagatorTmpl<TP>::setPartner(const TP& partner)
   {  partnerPtr_ = &partner; }
 
   /*
   * Add a source propagator to the list.
   */
   template <class TP>
   void PropagatorTmpl<TP>::addSource(const TP& source)
   {  sourcePtrs_.append(&source); }
 
   /*
   * Get partner propagator.
   */
   template <class TP>
   const TP& PropagatorTmpl<TP>::partner() 
   const
   {
      UTIL_CHECK(partnerPtr_);
      return *partnerPtr_;
   }
 
   /*
   * Mark this propagator as solved (true) or not (false).
   */
   template <class TP>
   void PropagatorTmpl<TP>::setIsSolved(bool isSolved)
   {  isSolved_ = isSolved; }
 
   /*
   * Check if all source propagators are marked completed.
   */
   template <class TP>
   bool PropagatorTmpl<TP>::isReady() const
   {
      for (int i=0; i < sourcePtrs_.size(); ++i) {
         if (!sourcePtrs_[i]->isSolved()) {
            return false;
         }
      }
      return true;
   }
 
}
#endif