SweepTmpl.h

#ifndef PSCF_SWEEP_TMPL_H
#define PSCF_SWEEP_TMPL_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/DArray.h>
#include <util/containers/GArray.h>
#include <pscf/sweep/ParameterModifier.h>
#include <pscf/sweep/ParameterType.h>
 
namespace Pscf {
 
   using namespace Util;

   template <typename State>
   class SweepTmpl : public ParamComposite
   {
 
   public:
 
      // Constructor and destructor are protected (see below).

      virtual void readParameters(std::istream& in);

      virtual void sweep();

      void addParameterType(std::string name, int nId, 
                            ParameterModifier& modifier);

      void addParameterType(ParameterType paramType);

      void addParameterTypes(GArray<ParameterType> paramTypes);
 
   protected:

      SweepTmpl(int historyCapacity);

      ~SweepTmpl();

      State& state(int i)
      {
         UTIL_CHECK(i < historySize_); 
         return *stateHistory_[i]; 
      }

      double s(int i) const
      {
         UTIL_CHECK(i < historySize_); 
         return sHistory_[i]; 
      }

      double c(int i) const
      {
         UTIL_CHECK(i >= 0); 
         UTIL_CHECK(i < historySize_); 
         return c_[i]; 
      }
 
      int historySize() const
      {  return historySize_; }
 
      int historyCapacity() const
      {  return historyCapacity_; }
 
      int nAccept() const
      {  return nAccept_; }

      void initialize();

      virtual void checkAllocation(State & state) = 0;

      virtual void setup() = 0;

      virtual void setParameters(double sNew) = 0;

      virtual void extrapolate(double sNew) = 0;

      void setCoefficients(double sNew);

      virtual int solve(bool isContinuation) = 0;

      virtual void reset() = 0;

      virtual void getSolution() = 0;

      virtual void cleanup();
 
      // Protected member variables

      int ns_;

      std::string baseFileName_;

      GArray<ParameterType> parameterTypes_;
 
   private:

      DArray<State> states_;

      DArray<double> sHistory_;

      DArray<State*> stateHistory_;

      DArray<double> c_;

      int historyCapacity_;

      int historySize_;

      int nAccept_;

      bool reuseState_;

      void accept(double s);

      SweepTmpl();
 
   };
 
} // namespace Pscf
#include "SweepTmpl.tpp"
#endif