FieldState.h

#ifndef PRDC_FIELD_STATE_H
#define PRDC_FIELD_STATE_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 <prdc/crystal/UnitCell.h>        // member
#include <util/containers/DArray.h>       // member template
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;
   using namespace Prdc;

   template <int D, class FT, class ST>
   class FieldState 
   {
 
   public:


      FieldState();

      FieldState(ST& system);

      ~FieldState();

      void setSystem(ST& system);


      const DArray<FT>& fields() const;

      DArray<FT>& fields();

      const FT& field(int monomerId) const;

      FT& field(int monomerId);

      const UnitCell<D>& unitCell() const;

      UnitCell<D>& unitCell();

 
   protected:

      bool hasSystem();

      ST& system();
 
   private:

      DArray<FT> fields_;

      UnitCell<D> unitCell_;

      ST* systemPtr_;
 
   };
 
   // Public inline member functions
 
   // Get an array of all fields (const reference)
   template <int D, class FT, class ST> inline
   const DArray<FT>& FieldState<D,FT,ST>::fields() const
   {  return fields_; }
 
   // Get an array of all fields (non-const reference)
   template <int D, class FT, class ST> inline
   DArray<FT>& FieldState<D,FT,ST>::fields()
   {  return fields_; }
 
   // Get field for monomer type id (const reference)
   template <int D, class FT, class ST> inline
   const FT& FieldState<D,FT,ST>::field(int id) const
   {  return fields_[id]; }
 
   // Get field for monomer type id (non-const reference)
   template <int D, class FT, class ST> inline 
   FT& FieldState<D,FT,ST>::field(int id)
   {  return fields_[id]; }
 
   // Get the internal Unitcell (const reference)
   template <int D, class FT, class ST> inline 
   const UnitCell<D>& FieldState<D,FT,ST>::unitCell() const
   { return unitCell_; }
 
   // Get the internal Unitcell (non-const reference)
   template <int D, class FT, class ST> inline 
   UnitCell<D>& FieldState<D,FT,ST>::unitCell()
   { return unitCell_; }
 
   // Protected inline member functions
 
   // Has the system been set?
   template <int D, class FT, class ST> inline 
   bool FieldState<D,FT,ST>::hasSystem()
   {  return (systemPtr_ != 0); }
   
   // Get the associated ST object.
   template <int D, class FT, class ST> inline 
   ST& FieldState<D,FT,ST>::system()
   {
      assert(systemPtr_);  
      return *systemPtr_; 
   }
 
   // Noninline public member functions
 
   /*
   * Constructor.
   */
   template <int D, class FT, class ST>
   FieldState<D,FT,ST>::FieldState()
    : fields_(),
      unitCell_(),
      systemPtr_(nullptr)
   {}
  
   /*
   * Constructor.
   */
   template <int D, class FT, class ST>
   FieldState<D,FT,ST>::FieldState(ST& system)
    : fields_(),
      unitCell_(),
      systemPtr_(nullptr)
   {  setSystem(system); }
 
   /*
   * Destructor.
   */
   template <int D, class FT, class ST>
   FieldState<D,FT,ST>::~FieldState()
   {}
 
   /*
   * Set association with system, after default construction.
   */
   template <int D, class FT, class ST>
   void FieldState<D,FT,ST>::setSystem(ST& system)
   {
      if (hasSystem()) {
         UTIL_CHECK(systemPtr_ == &system);
      } else {
         systemPtr_ = &system;
      }
   }
 
} // namespace Prdc
} // namespace Pscf
#endif