rpg/scft/iterator/Iterator.h

#ifndef RPG_ITERATOR_H
#define RPG_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 <prdc/cuda/types.h>              // typedef
#include <pscf/cuda/DeviceArray.h>        // typedef
#include <util/containers/FSArray.h>      // member
 
namespace Pscf {
namespace Rpg {
 
   template <int D> class System;
 
   using namespace Util;
   using namespace Prdc;
   using namespace Prdc::Cuda;
 
   typedef DeviceArray<cudaReal> FieldCUDA;

   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;

      bool isFlexible() const;

      FSArray<bool, 6> flexibleParams() const;

      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>& system();

      System<D> const & system() const;
 
   private:

      System<D>* sysPtr_;
 
   };
 
   // Protected inline member functions
 
   // Return reference to parent system.
   template<int D> inline 
   System<D>& Iterator<D>::system()
   {  return *sysPtr_; }
 
   // Return const reference to parent system.
   template<int D> inline 
   System<D> const & Iterator<D>::system() const
   {  return *sysPtr_; }
 
   // Explicit instantiation declarations
   extern template class Iterator<1>;
   extern template class Iterator<2>;
   extern template class Iterator<3>;
 
} // namespace Rpg
} // namespace Pscf
#endif