rp/scft/sweep/SweepParameter.h

#ifndef RP_SWEEP_PARAMETER_H
#define RP_SWEEP_PARAMETER_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/ParameterType.h>
#include <util/containers/DArray.h>
#include <util/containers/GArray.h>
#include <iostream>
#include <string>
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class T>
   class SweepParameter
   {
 
   public:

      void setSystem(typename T::System& system)
      {  systemPtr_ = &system; }

      void setParameterTypesArray(GArray<ParameterType>& array)
      {  parameterTypesPtr_ = &array; }

      ParameterType& parameterType() const;

      int parameterTypeId() const
      {  return parameterTypeId_; }

      bool isSpecialized() const
      {  return (parameterTypeId_ != -1); }

      void getInitial();

      void update(double newVal);

      std::string type() const;

      void writeParamType(std::ostream& out) const;

      int id(int i) const
      {
         UTIL_CHECK(i >= 0);
         UTIL_CHECK(i < nId_);
         return id_[i];
      }

      int nId() const
      {  return nId_; }

      double current()
      {  return get_(); }

      double initial() const
      {  return initial_; }

      double change() const
      {  return change_; }

      template <class Archive>
      void serialize(Archive ar, const unsigned int version);
 
   protected:

      SweepParameter();

      SweepParameter(typename T::System& system);
 
   private:

      enum ParamType { Block, Chi, Kuhn, Phi_Polymer, Phi_Solvent,
                       Mu_Polymer, Mu_Solvent, Solvent, Cell_Param,
                       Special, Null};

      ParamType type_;

      int nId_;

      DArray<int> id_;

      double initial_;

      double change_;

      typename T::System* systemPtr_;

      GArray<ParameterType>* parameterTypesPtr_;

      int parameterTypeId_;

      void readParamType(std::istream& in);

      double get_();

      void set_(double newVal);
 
   // friends:
 
      template <int DT, class TT>
      friend std::istream& 
      operator >> (std::istream&, SweepParameter<DT,TT>&);
 
      template <int DT, class TT>
      friend std::ostream& 
      operator << (std::ostream&, SweepParameter<DT,TT> const&);
 
   };
 
   /*
   * Serialize member function.
   */
   template <int D, class T>
   template <class Archive>
   void SweepParameter<D,T>::serialize(Archive ar, 
                                       const unsigned int version)
   {
      serializeEnum(ar, type_, version);
      ar & nId_;
      for (int i = 0; i < nId_; ++i) {
         ar & id_[i];
      }
      ar & initial_;
      ar & change_;
   }

   template <int D, class T>
   std::istream& operator >> (std::istream& in,
                              SweepParameter<D,T>& param)
   {
      // Read the parameter type identifier string
      param.readParamType(in);
 
      // Read the identifiers associated with this parameter type.
      for (int i = 0; i < param.nId_; ++i) {
         in >> param.id_[i];
      }
      // Read in the range in the parameter to sweep over
      in >> param.change_;
 
      return in;
   }

   template <int D, class T>
   std::ostream& operator << (std::ostream& out,
                              SweepParameter<D,T> const & param)
   {
      param.writeParamType(out);
      out << "  ";
      for (int i = 0; i < param.nId_; ++i) {
         out << param.id(i);
         out << " ";
      }
      out << param.change_;
 
      return out;
   }
 
}
}
#endif