rp/scft/sweep/Sweep.h

#ifndef RP_SWEEP_H
#define RP_SWEEP_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 <pscf/sweep/SweepTmpl.h>          // base class template
#include <util/containers/FSArray.h>       // member
#include <util/global.h>                   // inline functions
 
#include <fstream>
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class T>
   class Sweep : public SweepTmpl< typename T::BasisFieldState >
   {
 
   public:

      void setSystem(typename T::System& system);

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

      Sweep();

      Sweep(typename T::System& system);

      ~Sweep();

      virtual void checkAllocation(typename T::BasisFieldState& state);

      virtual void setup();

      virtual void setParameters(double sNew) = 0;

      virtual void extrapolate(double sNew);

      virtual int solve(bool isContinuation);

      virtual void reset();

      virtual void getSolution();

      virtual void cleanup();

      bool hasSystem()
      {  return (bool)(systemPtr_); }

      typename T::System& system()
      {
         UTIL_CHECK(systemPtr_);
         return *systemPtr_;
      }
 
      // Protected variables writeCGrid_, writeCBasis_, and writeWGrid_
      // control which converged fields will be written to files after
      // solution of each SCFT problem within a sweep.

      bool writeCRGrid_;

      bool writeCBasis_;

      bool writeWRGrid_;
 
   private:

      typename T::BasisFieldState trial_;

      FSArray<double, 6> unitCellParameters_;

      std::ofstream logFile_;

      typename T::System* systemPtr_;

      void outputSolution();

      void outputSummary(std::ostream&);
 
      // Private alias for base class.
      using SweepTmplT = SweepTmpl< typename T::BasisFieldState >;
 
   };
 
} // namespace Rp
} // namespace Pscf
#endif