cp/solvers/Mixture.h

#ifndef PRDC_CL_MIXTURE_H
#define PRDC_CL_MIXTURE_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 <pscf/solvers/MixtureTmpl.h>   // base class template
#include <iostream>
 
// Forward declarations
namespace Util {
   template <typename T> class DArray;
}
namespace Pscf {
   template <int D> class Mesh;
   namespace Prdc {
      template <int D> class UnitCell;
   }
}
 
namespace Pscf {
namespace Cp {
 
   using namespace Util;
   using namespace Prdc;

   template <int D, class PT, class ST, class TT>
   class Mixture : public MixtureTmpl< PT, ST, std::complex<double> >
   {
 
   public:
 
      // Public type name aliases

      using MixtureTmplT = MixtureTmpl< PT, ST, std::complex<double> >;

      using MixtureBaseT = MixtureBase< std::complex<double> >;

      using typename MixtureTmplT::SolventT;

      using typename MixtureTmplT::PolymerT;

      using BlockT = typename TT::Block;

      using PropagatorT = typename TT::Propagator;

      using FieldT = typename TT::CField;

      using FFTT = typename TT::FFT;

      using WaveListT = typename TT::WaveList;

      using FieldIoT = typename TT::FieldIo;
 
      // Public member functions


      Mixture();

      ~Mixture();

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

      void associate(Mesh<D> const & mesh,
                     FFTT const & fft,
                     UnitCell<D> const & cell,
                     WaveListT& waveList);

      void setFieldIo(FieldIoT const & fieldIo);

      void allocate();


      void compute(DArray<FieldT> const & wFields,
                   DArray<FieldT>& cFields);


      void setKuhn(int monomerId, double kuhn);

      void clearUnitCellData();

 
      #if 0  // Delay implementation and testing

      void createBlockCRGrid(DArray<FieldT>& blockCFields) const;

      void writeBlockCRGrid(std::string const & filename) const;

      #endif
 
      #if 0  // Delay implementation and testing
      
      void writeQSlice(std::string const & filename,
                       int polymerId, int blockId,
                       int directionId, int segmentId)  const;

      void writeQTail(std::string const & filename, int polymerId,
                      int blockId, int directionId)  const;

      void writeQ(std::string const & filename, int polymerId,
                  int blockId, int directionId)  const;

      void writeQAll(std::string const & basename);

      #endif
 
      // Inherited public member functions
      using MixtureTmplT::polymer;
      using MixtureTmplT::polymerSpecies;
      using MixtureTmplT::solvent;
      using MixtureTmplT::solventSpecies;
      using MixtureBaseT::nMonomer;
      using MixtureBaseT::monomer;
      using MixtureBaseT::nPolymer;
      using MixtureBaseT::nSolvent;
      using MixtureBaseT::nBlock;
      using MixtureBaseT::vMonomer;
      using MixtureBaseT::isCanonical;
 
   protected:

      Mesh<D> const & mesh() const
      {  return *meshPtr_; }

      UnitCell<D> const & unitCell() const
      {  return *unitCellPtr_; }

      FieldIoT const & fieldIo() const
      {  return *fieldIoPtr_; }

      double ds() const
      {  return ds_; }
 
      // Inherited protected member functions
      using ParamComposite::setClassName;
      using ParamComposite::read;
      using ParamComposite::readOptional;
 
   private:
 
      // Private member data

      double ds_;

      Mesh<D> const * meshPtr_;
 
      // Pointer to associated UnitCell<D> object 
      UnitCell<D> const * unitCellPtr_;
 
      // Pointer to associated FieldIoT object 
      FieldIoT const * fieldIoPtr_;
 
      // Private member functions (pure virtual)

      virtual void eqS(FieldT& A, double s) const = 0;

      virtual void addEqV(FieldT& A, FieldT const & B) const = 0;

      virtual void allocateBlocks() = 0; 
 
   };
 
} // namespace Cp
} // namespace Pscf
#endif