SystemTmpl.h

#ifndef PRDC_SYSTEM_TMPL_H
#define PRDC_SYSTEM_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 <pscf/chem/PolymerModel.h>      // member
 
// Forward declarations
namespace Util {
   class FileMaster;
   template <typename E, int N> class FSArray;
}
namespace Pscf {
   namespace Prdc {
      template <int D> class UnitCell;
   }
}
 
namespace Pscf {
namespace Prdc {
 
   // Namespace that may be used implicitly
   using namespace Util;

   template <int D, class T>
   class SystemTmpl : public ParamComposite
   {
 
   public:
 
      // Public type name aliases
      using MixtureT = typename T::Mixture;
      using InteractionT = typename T::Interaction;
      using DomainT = typename T::Domain;
      using WFieldsT = typename T::WFields;
      using CFieldsT = typename T::CFields;
      using MaskT = typename T::Mask;
      using RFieldT = typename T::RField;


      SystemTmpl(typename T::System& system);

      ~SystemTmpl();
 
      // Suppress compiler-generated member functions
      SystemTmpl() = delete;
      SystemTmpl(SystemTmpl<D,T> const &) = delete;
      SystemTmpl<D,T>& operator = (SystemTmpl<D,T> const & ) = delete;


      void setOptions(int argc, char **argv);

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

      void readParam();

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

      void readCommands(std::istream& in);

      void readCommands();


      void compute(bool needStress = false);

      void computeStress();

      int iterate(bool isContinuation = false);

      void sweep();

      void simulate(int nStep);

      void clearCFields();


      void setUnitCell(UnitCell<D> const & unitCell);

      void setUnitCell(FSArray<double, 6> const & parameters);

      void clearUnitCellData();


      typename T::CFields const & c() const;

      typename T::WFields& w();

      typename T::WFields const & w() const;

      typename T::WFields& h();

      typename T::WFields const & h() const;

      typename T::Mask& mask();

      typename T::Mask const & mask() const;


      typename T::Mixture const & mixture() const;

      typename T::MixtureModifier& mixtureModifier();

      typename T::Interaction& interaction();

      typename T::Interaction const & interaction() const;

      typename T::Domain const & domain() const;

      bool hasEnvironment() const;

      typename T::Environment& environment();

      typename T::Environment const & environment() const;

      typename T::ScftThermo& scft();

      typename T::ScftThermo const & scft() const;

      bool hasIterator() const;

      typename T::Iterator& iterator();

      typename T::Iterator const & iterator() const;

      bool hasSweep() const;

      bool hasSimulator() const;

      typename T::Simulator& simulator();

      typename T::Simulator const & simulator() const;

      FileMaster& fileMaster();

      FileMaster const & fileMaster() const;


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


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

      void clearTimers();

 
   protected:

      virtual void setThreadCount(int nThread)
      {};
 
   private:
 
      // Component objects

      typename T::WFields w_;

      typename T::CFields c_;

      typename T::WFields h_;

      typename T::Mask mask_;
 
      // Pointers to associated objects

      typename T::System* systemPtr_;

      typename T::Mixture* mixturePtr_;

      typename T::MixtureModifier* mixtureModifierPtr_;

      typename T::Domain* domainPtr_;

      typename T::Interaction* interactionPtr_;

      typename T::Environment* environmentPtr_;

      typename T::EnvironmentFactory* environmentFactoryPtr_;

      typename T::ScftThermo* scftPtr_;

      typename T::Iterator* iteratorPtr_;

      typename T::IteratorFactory* iteratorFactoryPtr_;

      typename T::Sweep* sweepPtr_;

      typename T::SweepFactory* sweepFactoryPtr_;

      typename T::Simulator* simulatorPtr_;

      typename T::SimulatorFactory* simulatorFactoryPtr_;

      FileMaster* fileMasterPtr_;

      UnitCell<D>* tmpUnitCellPtr_;

      PolymerModel::Type polymerModel_;
 
      // Boolean state variables

      bool isAllocatedGrid_;

      bool isAllocatedBasis_;

      bool hasMixture_;
 
      #if 0
      // Mutable work space
 
      mutable UnitCell<D> tmpUnitCell_;
      #endif
 
      // Private member functions

      typename T::Mixture & mixture_();

      typename T::Domain& domain_();

      void allocateFieldsGrid();

      void allocateFieldsBasis();

      void readEcho(std::istream& in, std::string& string) const;

      void readEcho(std::istream& in, double& value) const;
 
   };
 
   // Inline member functions
 
   // Get the Mixture (const).
   template <int D, class T> inline 
   typename T::Mixture const & SystemTmpl<D,T>::mixture() const
   {  return *mixturePtr_; }
 
   // Get the MixtureModifier (non-const).
   template <int D, class T> inline 
   typename T::MixtureModifier& SystemTmpl<D,T>::mixtureModifier()
   {
      UTIL_ASSERT(mixtureModifierPtr_);
      return *mixtureModifierPtr_;
   }
 
   // Get the %Interaction (non-const).
   template <int D, class T> inline 
   typename T::Interaction& SystemTmpl<D,T>::interaction()
   {
      UTIL_ASSERT(interactionPtr_);
      return *interactionPtr_;
   }
 
   // Get the %Interaction (const).
   template <int D, class T> inline 
   typename T::Interaction const & SystemTmpl<D,T>::interaction() const
   {
      UTIL_ASSERT(interactionPtr_);
      return *interactionPtr_;
   }
 
   // Get the Domain (const).
   template <int D, class T> inline 
   typename T::Domain const & SystemTmpl<D,T>::domain() const
   {  return *domainPtr_; }
 
   // Does this system have an %Environment?
   template <int D, class T> inline 
   bool SystemTmpl<D,T>::hasEnvironment() const
   {  return (environmentPtr_); }
 
   // Get the %Environment (non-const).
   template <int D, class T> inline 
   typename T::Environment & SystemTmpl<D,T>::environment()
   {
      UTIL_ASSERT(environmentPtr_);
      return *environmentPtr_;
   }
 
   // Get the %Environment (const).
   template <int D, class T> inline 
   typename T::Environment const & SystemTmpl<D,T>::environment() const
   {
      UTIL_ASSERT(environmentPtr_);
      return *environmentPtr_;
   }
 
   // Get the Scft calculator (non-const).
   template <int D, class T> inline 
   typename T::ScftThermo & SystemTmpl<D,T>::scft()
   {
      UTIL_ASSERT(scftPtr_);
      return *scftPtr_;
   }
 
   // Get the Scft calculator (const).
   template <int D, class T> inline 
   typename T::ScftThermo const & SystemTmpl<D,T>::scft() const
   {
      UTIL_ASSERT(scftPtr_);
      return *scftPtr_;
   }
 
   // Does this system have an Iterator?
   template <int D, class T> inline 
   bool SystemTmpl<D,T>::hasIterator() const
   {  return (iteratorPtr_); }
 
   // Get the Iterator (non-const).
   template <int D, class T> inline 
   typename T::Iterator& SystemTmpl<D,T>::iterator()
   {
      UTIL_ASSERT(iteratorPtr_);
      return *iteratorPtr_;
   }
 
   // Get the Iterator (const).
   template <int D, class T> inline 
   typename T::Iterator const & SystemTmpl<D,T>::iterator() const
   {
      UTIL_ASSERT(iteratorPtr_);
      return *iteratorPtr_;
   }
 
   // Does this system have a Sweep?
   template <int D, class T> inline 
   bool SystemTmpl<D,T>::hasSweep() const
   {  return (sweepPtr_); }
 
   // Does this system have a Simulator?
   template <int D, class T> inline 
   bool SystemTmpl<D,T>::hasSimulator() const
   {  return (simulatorPtr_); }
 
   // Get the Simulator (non-const).
   template <int D, class T> inline 
   typename T::Simulator& SystemTmpl<D,T>::simulator()
   {
      UTIL_ASSERT(simulatorPtr_);
      return *simulatorPtr_;
   }
 
   // Get the Simulator (const).
   template <int D, class T> inline 
   typename T::Simulator const & SystemTmpl<D,T>::simulator() const
   {
      UTIL_ASSERT(simulatorPtr_);
      return *simulatorPtr_;
   }
 
   // Get the FileMaster (non-const).
   template <int D, class T> inline 
   FileMaster& SystemTmpl<D,T>::fileMaster()
   {  return *fileMasterPtr_; }
 
   // Get the FileMaster (const).
   template <int D, class T> inline 
   FileMaster const & SystemTmpl<D,T>::fileMaster() const
   {  return *fileMasterPtr_; }
 
   // Get the container of c fields (const).
   template <int D, class T> inline
   typename T::CFields const & SystemTmpl<D,T>::c() const
   {  return c_; }
 
   // Get the container of w fields (non-const).
   template <int D, class T> inline
   typename T::WFields& SystemTmpl<D,T>::w()
   {  return w_; }
 
   // Get the container of w fields (const).
   template <int D, class T> inline
   typename T::WFields const & SystemTmpl<D,T>::w() const
   {  return w_; }
 
   // Get the container of external fields (non-const).
   template <int D, class T> inline 
   typename T::WFields& SystemTmpl<D,T>::h()
   {  return h_; }
 
   // Get the container of external fields (const).
   template <int D, class T> inline 
   typename T::WFields const & SystemTmpl<D,T>::h() const
   {  return h_; }
 
   // Get the mask field (non-const).
   template <int D, class T> inline 
   typename T::Mask& SystemTmpl<D,T>::mask()
   {  return mask_; }
 
   // Get the mask field (const).
   template <int D, class T> inline 
   typename T::Mask const & SystemTmpl<D,T>::mask() const
   {  return mask_; }
 
   // Private inline functions:
 
   // Get the Mixture (non-const).
   template <int D, class T> inline 
   typename T::Mixture & SystemTmpl<D,T>::mixture_() 
   {  return *mixturePtr_; }
 
   // Get the Domain (non-const).
   template <int D, class T> inline 
   typename T::Domain & SystemTmpl<D,T>::domain_() 
   {  return *domainPtr_; }
 
} // namespace Prdc
} // namespace Pscf
#endif