rpc/scft/iterator/Iterator.h

#ifndef RPC_ITERATOR_H
#define RPC_ITERATOR_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/param/ParamComposite.h>    // base class
#include <util/containers/FSArray.h>      // member
#include <util/global.h>
 
namespace Pscf {
namespace Rpc {
 
   template <int D> class System;
 
   using namespace Util;

   template <int D>
   class Iterator : public ParamComposite
   {
 
   public:

      Iterator();

      Iterator(System<D>& system);

      ~Iterator();

      virtual int solve(bool isContinuation) = 0;
      
      virtual void outputTimers(std::ostream& out) const = 0;
      
      virtual void clearTimers() = 0;

      bool isSymmetric() const
      {  return (isSymmetric_); }

      bool isFlexible() const
      {  return (isFlexible_); }

      FSArray<bool,6> flexibleParams() const
      {  return flexibleParams_; }

      int nFlexibleParams() const;
 
      void setFlexibleParams(FSArray<bool,6> const & flexParams);
 
      virtual double stress(int paramId) const;
 
   protected:

      bool isSymmetric_;
    
      bool isFlexible_;

      FSArray<bool,6> flexibleParams_;

      System<D> const & system() const;

      System<D>& system();
 
   private:

      System<D>* sysPtr_;
      
   };
 
   // Inline member functions

   template <int D> inline
   System<D> const & Iterator<D>::system() const
   {
      UTIL_CHECK(sysPtr_);  
      return *sysPtr_; 
   }

   template <int D> inline
   System<D>& Iterator<D>::system() 
   {  
      UTIL_CHECK(sysPtr_);  
      return *sysPtr_; 
   }
 
   // Explicit instantiation declarations
   extern template class Iterator<1>;
   extern template class Iterator<2>;
   extern template class Iterator<3>;
 
} // namespace Rpc
} // namespace Pscf
#endif