FilmIteratorBase.h

#ifndef PSPC_FILM_ITERATOR_BASE_H
#define PSPC_FILM_ITERATOR_BASE_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2021, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "pspc/iterator/Iterator.h"        // base class
#include "util/containers/FSArray.h"       // container
#include <string>
#include <iostream>
 
namespace Pscf {
namespace Pspc
{
 
   template <int D>
   class System;
   
   using namespace Util;
 
   template <int D, typename IteratorType>
   class FilmIteratorBase : public Iterator<D>
   {
 
   public:
 
      FilmIteratorBase(System<D>& system);
 
      ~FilmIteratorBase();
 
      void readParameters(std::istream& in);
 
      int solve(bool isContinuation = false);
 
      IteratorType const & iterator() const;
 
      virtual void setFlexibleParams() = 0;
 
      virtual void checkLatticeVectors() const = 0;
 
      void generateWallFields();
 
      void updateWallFields();
 
      void checkSpaceGroup() const;
 
      bool isSymmetric() const;
 
      bool isAthermal() const;
 
      void setChiBottom(int s, double chi);
 
      void setChiTop(int s, double chi);
 
      int normalVecId() const;
 
      double interfaceThickness() const;
 
      double wallThickness() const;
 
      DArray<double> const & chiTop() const;
 
      DArray<double> const & chiBottom() const;
 
      double chiBottom(int s) const;
 
      double chiTop(int s) const;
 
      using Iterator<D>::isFlexible;
 
   protected:
 
      void setup();
      
      IteratorType& iterator();
 
      void generateExternalFields();
 
      using Iterator<D>::system;
      using Iterator<D>::setClassName;
      using Iterator<D>::isFlexible_;
      using ParamComposite::read;
      using ParamComposite::readOptional;
      using ParamComposite::readDArray;
      using ParamComposite::setParent;
      using ParamComposite::addComponent;
 
   private:
 
      IteratorType iterator_;
 
      FSArray<double, 6> parameters_;
 
      int normalVecId_;
 
      double t_;
 
      double T_;
 
      DArray<double> chiBottom_;
 
      DArray<double> chiTop_;
 
      DArray<double> chiBottomCurrent_;
 
      DArray<double> chiTopCurrent_;
 
      bool ungenerated_;
   };
 
   // Inline member functions
 
   // Return reference to iterator within this FilmIterator
   template <int D, typename IteratorType>
   inline IteratorType& FilmIteratorBase<D, IteratorType>::iterator()
   {  return iterator_; }
 
   // Return const reference to iterator within this FilmIterator
   template <int D, typename IteratorType>
   inline 
   IteratorType const & FilmIteratorBase<D, IteratorType>::iterator() const
   {  return iterator_; }
 
   // Set value of chi between species s and the bottom wall
   template <int D, typename IteratorType>
   inline 
   void FilmIteratorBase<D, IteratorType>::setChiBottom(int s, double chi)
   {  chiBottom_[s] = chi; }
 
   // Set value of chi between species s and the top wall
   template <int D, typename IteratorType>
   inline 
   void FilmIteratorBase<D, IteratorType>::setChiTop(int s, double chi)
   {  chiTop_[s] = chi; }
 
   // Get value of normalVecId
   template <int D, typename IteratorType>
   inline int FilmIteratorBase<D, IteratorType>::normalVecId() const
   {  return normalVecId_; }
 
   // Get value of interfaceThickness
   template <int D, typename IteratorType>
   inline double FilmIteratorBase<D, IteratorType>::interfaceThickness() 
   const
   {  return t_; }
 
   // Get value of wallThickness
   template <int D, typename IteratorType>
   inline double FilmIteratorBase<D, IteratorType>::wallThickness() const
   {  return T_; }
 
   // Get chiBottom array by const reference
   template <int D, typename IteratorType>
   inline 
   DArray<double> const & FilmIteratorBase<D, IteratorType>::chiBottom() 
   const
   {  return chiBottom_; }
 
   // Get chiTop array by const reference
   template <int D, typename IteratorType>
   inline 
   DArray<double> const & FilmIteratorBase<D, IteratorType>::chiTop() 
   const
   {  return chiTop_; }
 
   // Get the chi parameter between the bottom wall and species s
   template <int D, typename IteratorType>
   inline double FilmIteratorBase<D, IteratorType>::chiBottom(int s) 
   const
   {  return chiBottom_[s]; }
 
   // Get the chi parameter between the top wall and species s
   template <int D, typename IteratorType>
   inline double FilmIteratorBase<D, IteratorType>::chiTop(int s) 
   const
   {  return chiTop_[s]; }
 
} // namespace Pspc
} // namespace Pscf
 
#include "FilmIteratorBase.tpp"
#endif