SweepTmpl.h

#ifndef PSCF_SWEEP_TMPL_H
#define PSCF_SWEEP_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/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 is protected (see below).
 
      ~SweepTmpl();
 
      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:
 
      int ns_;
 
      std::string baseFileName_;
 
      GArray<ParameterType> parameterTypes_;
 
      SweepTmpl(int historyCapacity);
 
      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();
 
   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