rpg/system/System.h

#ifndef RPG_SYSTEM_H
#define RPG_SYSTEM_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.
*/
 
// Header file includes
#include <util/param/ParamComposite.h>   // base class
#include <rpg/solvers/Mixture.h>         // member
#include <rpg/field/Domain.h>            // member
#include <rpg/field/WFieldContainer.h>   // member
#include <rpg/field/CFieldContainer.h>   // member
#include <rpg/field/Mask.h>              // member
#include <prdc/crystal/UnitCell.h>       // member
#include <pscf/chem/PolymerModel.h>      // member
#include <util/misc/FileMaster.h>        // member
 
// Forward declarations
namespace Util {
   template <typename T, int N> class FSArray;
}
namespace Pscf {
   class Interaction;
   namespace Prdc {
      class Environment;
      namespace Cuda {
         template <int D> class RField;
      }
   }
   namespace Rpg {
      template <int D> class MixtureModifier;
      template <int D> class EnvironmentFactory;
      template <int D> class ScftThermo;
      template <int D> class Iterator;
      template <int D> class IteratorFactory;
      template <int D> class Sweep;
      template <int D> class SweepFactory;
      template <int D> class Simulator;
      template <int D> class SimulatorFactory;
   }
}
 
namespace Pscf {
namespace Rpg {
 
   // Namespaces that may be used implicitly
   using namespace Util;
   using namespace Prdc;
   using namespace Prdc::Cuda;

   template <int D>
   class System : public ParamComposite
   {
 
   public:
 
      // Public type name aliases
      using MixtureT = Mixture<D>;
      using InteractionT = Interaction;
      using DomainT = Domain<D>;
      using WFieldContainerT = WFieldContainer<D>;
      using CFieldContainerT = CFieldContainer<D>;
      using MaskT = Mask<D>;
      using FieldT = RField<D>;


      System();

      ~System();


      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();


      CFieldContainer<D> const & c() const;

      WFieldContainer<D>& w();

      WFieldContainer<D> const & w() const;

      WFieldContainer<D>& h();

      WFieldContainer<D> const & h() const;

      Mask<D>& mask();

      Mask<D> const & mask() const;


      Mixture<D> const & mixture() const;

      MixtureModifier<D>& mixtureModifier();

      Interaction& interaction();

      Interaction const & interaction() const;

      Domain<D> const & domain() const;

      bool hasEnvironment() const;

      Environment& environment();

      Environment const & environment() const;

      ScftThermo<D>& scft();

      ScftThermo<D> const & scft() const;

      bool hasIterator() const;

      Iterator<D>& iterator();

      Iterator<D> const & iterator() const;

      bool hasSweep() const;

      bool hasSimulator() const;

      Simulator<D>& simulator();

      Simulator<D> const & simulator() const;

      FileMaster& fileMaster();

      FileMaster const & fileMaster() const;


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


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

      void clearTimers();

 
   private:
 
      // Component objects

      Mixture<D> mixture_;

      Domain<D> domain_;

      FileMaster fileMaster_;

      WFieldContainer<D> w_;

      CFieldContainer<D> c_;

      WFieldContainer<D> h_;

      Mask<D> mask_;
 
      // Pointers to dynamic objects owned by this System

      MixtureModifier<D>* mixtureModifierPtr_;

      Interaction* interactionPtr_;

      Environment* environmentPtr_;

      EnvironmentFactory<D>* environmentFactoryPtr_;

      ScftThermo<D>* scftPtr_;

      Iterator<D>* iteratorPtr_;

      IteratorFactory<D>* iteratorFactoryPtr_;

      Sweep<D>* sweepPtr_;

      SweepFactory<D>* sweepFactoryPtr_;

      Simulator<D>* simulatorPtr_;

      SimulatorFactory<D>* simulatorFactoryPtr_;

      PolymerModel::Type polymerModel_;
 
      // Boolean state variables

      bool isAllocatedGrid_;

      bool isAllocatedBasis_;

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

      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>
   inline Mixture<D> const & System<D>::mixture() const
   {  return mixture_; }
 
   // Get the MixtureModifier (non-const).
   template <int D>
   inline MixtureModifier<D>& System<D>::mixtureModifier()
   {
      UTIL_ASSERT(mixtureModifierPtr_);
      return *mixtureModifierPtr_;
   }
 
   // Get the Interaction (non-const).
   template <int D>
   inline Interaction& System<D>::interaction()
   {
      UTIL_ASSERT(interactionPtr_);
      return *interactionPtr_;
   }
 
   // Get the Interaction (const).
   template <int D>
   inline Interaction const & System<D>::interaction() const
   {
      UTIL_ASSERT(interactionPtr_);
      return *interactionPtr_;
   }
 
   // Get the Domain (const).
   template <int D>
   inline Domain<D> const & System<D>::domain() const
   {  return domain_; }
 
   // Does this system have an Environment?
   template <int D>
   inline bool System<D>::hasEnvironment() const
   {  return (environmentPtr_); }
 
   // Get the Environment (non-const).
   template <int D>
   inline Environment & System<D>::environment()
   {
      UTIL_ASSERT(environmentPtr_);
      return *environmentPtr_;
   }
 
   // Get the Environment (const).
   template <int D>
   inline Environment const & System<D>::environment() const
   {
      UTIL_ASSERT(environmentPtr_);
      return *environmentPtr_;
   }
 
   // Get the Scft calculator (non-const).
   template <int D>
   inline ScftThermo<D> & System<D>::scft()
   {
      UTIL_ASSERT(scftPtr_);
      return *scftPtr_;
   }
 
   // Get the Scft calculator (const).
   template <int D>
   inline ScftThermo<D> const & System<D>::scft() const
   {
      UTIL_ASSERT(scftPtr_);
      return *scftPtr_;
   }
 
   // Does this system have an Iterator?
   template <int D>
   inline bool System<D>::hasIterator() const
   {  return (iteratorPtr_); }
 
   // Get the Iterator (non-const).
   template <int D>
   inline Iterator<D>& System<D>::iterator()
   {
      UTIL_ASSERT(iteratorPtr_);
      return *iteratorPtr_;
   }
 
   // Get the Iterator (const).
   template <int D>
   inline Iterator<D> const & System<D>::iterator() const
   {
      UTIL_ASSERT(iteratorPtr_);
      return *iteratorPtr_;
   }
 
   // Does this system have a Sweep?
   template <int D>
   inline bool System<D>::hasSweep() const
   {  return (sweepPtr_); }
 
   // Does this system have a Simulator?
   template <int D>
   inline bool System<D>::hasSimulator() const
   {  return (simulatorPtr_); }
 
   // Get the Simulator (non-const).
   template <int D>
   inline Simulator<D>& System<D>::simulator()
   {
      UTIL_ASSERT(simulatorPtr_);
      return *simulatorPtr_;
   }
 
   // Get the Simulator (const).
   template <int D>
   inline Simulator<D> const & System<D>::simulator() const
   {
      UTIL_ASSERT(simulatorPtr_);
      return *simulatorPtr_;
   }
 
   // Get the FileMaster (non-const).
   template <int D>
   inline FileMaster& System<D>::fileMaster()
   {  return fileMaster_; }
 
   // Get the FileMaster (const).
   template <int D>
   inline FileMaster const & System<D>::fileMaster() const
   {  return fileMaster_; }
 
   // Get the container of c fields (const).
   template <int D>
   inline
   CFieldContainer<D> const & System<D>::c() const
   {  return c_; }
 
   // Get the container of w fields (non-const).
   template <int D>
   inline
   WFieldContainer<D>& System<D>::w()
   {  return w_; }
 
   // Get the container of w fields (const).
   template <int D>
   inline
   WFieldContainer<D> const & System<D>::w() const
   {  return w_; }
 
   // Get the container of external fields (non-const).
   template <int D>
   inline WFieldContainer<D>& System<D>::h()
   {  return h_; }
 
   // Get the container of external fields (const).
   template <int D>
   inline WFieldContainer<D> const & System<D>::h() const
   {  return h_; }
 
   // Get the mask field (non-const).
   template <int D>
   inline Mask<D>& System<D>::mask()
   {  return mask_; }
 
   // Get the mask field (const).
   template <int D>
   inline Mask<D> const & System<D>::mask() const
   {  return mask_; }
 
   #ifndef RPG_SYSTEM_TPP
   // Suppress implicit instantiation
   extern template class System<1>;
   extern template class System<2>;
   extern template class System<3>;
   #endif
 
} // namespace Rpg
} // namespace Pscf
#endif