rpc/scft/sweep/SweepParameter.h

#ifndef RPC_SWEEP_PARAMETER_H
#define RPC_SWEEP_PARAMETER_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 <iostream>
#include <string>
#include <pscf/sweep/ParameterType.h>
 
namespace Pscf {
namespace Rpc {
 
   template <int D> class System;
 
   template <int D>
   class SweepParameter
   {
 
   public:
 
      SweepParameter();
 
      SweepParameter(System<D>& system);
 
      void setSystem(System<D>& 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 < 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);
 
   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_;
 
      System<D>* systemPtr_;
 
      GArray<ParameterType>* parameterTypesPtr_;
 
      int parameterTypeId_;
 
      void readParamType(std::istream& in);
 
      double get_();
 
      void set_(double newVal);
 
   // friends:
 
      template <int U>
      friend
      std::istream& operator >> (std::istream&, SweepParameter<U>&);
 
      template <int U>
      friend
      std::ostream& operator << (std::ostream&, SweepParameter<U> const&);
 
   };
 
   template <int D>
   std::istream& operator >> (std::istream& in, 
                              SweepParameter<D>& param);
 
   template <int D>
   std::ostream& operator << (std::ostream& out, 
                              SweepParameter<D> const & param);
 
}
}
#include "SweepParameter.tpp"
#endif