rpg/solvers/Mixture.h

#ifndef RPG_MIXTURE_H
#define RPG_MIXTURE_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "Polymer.h"
#include "Solvent.h"
#include <pscf/solvers/MixtureTmpl.h>
#include <pscf/inter/Interaction.h>
#include <util/containers/DArray.h>
 
namespace Pscf { 
   template <int D> class Mesh; 
   namespace Prdc {
      namespace Cuda {
         template <int D> class FFT; 
      }
   }
}
 
namespace Pscf {
namespace Rpg
{
 
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cuda;
 
   template <int D>
   class Mixture : public MixtureTmpl< Polymer<D>, Solvent<D> >
   {
 
   public:
 
      Mixture();
 
      ~Mixture();
 
      void readParameters(std::istream& in);
 
      void associate(Mesh<D> const & mesh, FFT<D> const & fft, 
                     UnitCell<D> const & cell, WaveList<D>& wavelist);
 
      void allocate();
 
      void clearUnitCellData();
 
      void setKuhn(int monomerId, double kuhn);
 
      void compute(DArray< RField<D> > const & wFields, 
                   DArray< RField<D> > & cFields, 
                   double phiTot = 1.0);
 
      void computeStress(double phiTot = 1.0);
 
      void createBlockCRGrid(DArray< RField<D> >& blockCFields) const;
 
      double stress(int parameterId) const;
 
      #if 0
      double vMonomer() const;
      #endif
 
      bool isCanonical();
    
      // Public members from MixtureTmpl with non-dependent names 
      using MixtureTmpl< Polymer<D>, Solvent<D> >::nMonomer;
      using MixtureTmpl< Polymer<D>, Solvent<D> >::nPolymer;
      using MixtureTmpl< Polymer<D>, Solvent<D> >::nSolvent;
      using MixtureTmpl< Polymer<D>, Solvent<D> >::nBlock;
      using MixtureTmpl< Polymer<D>, Solvent<D> >::polymer;
      using MixtureTmpl< Polymer<D>, Solvent<D> >::monomer;
      using MixtureTmpl< Polymer<D>, Solvent<D> >::solvent;
 
   protected:
 
      // Public members from MixtureTmpl with non-dependent names 
      using MixtureTmpl< Polymer<D>, Solvent<D> >::setClassName;
      using ParamComposite::read;
      using ParamComposite::readOptional;
 
   private:
 
      FArray<double, 6> stress_;
   
      double ds_;
 
      Mesh<D> const * meshPtr_;
 
      int nParams_;
 
      bool hasStress_;
 
      bool useBatchedFFT_;
 
      // Private function
      
      Mesh<D> const & mesh() const;
 
   };
 
   // Inline member function
 
   /*
   * Get Mesh<D> by constant reference (private).
   */
   template <int D>
   inline Mesh<D> const & Mixture<D>::mesh() const
   {   
      UTIL_ASSERT(meshPtr_);
      return *meshPtr_;
   }
 
   /*
   * Get derivative of free energy w/ respect to cell parameter.
   */
   template <int D>
   inline double Mixture<D>::stress(int parameterId) const
   {
      UTIL_CHECK(hasStress_);  
      return stress_[parameterId]; 
   }
 
   #ifndef RPG_MIXTURE_TPP
   // Suppress implicit instantiation
   extern template class Mixture<1>;
   extern template class Mixture<2>;
   extern template class Mixture<3>;
   #endif
 
} // namespace Rpg
} // namespace Pscf
//#include "Mixture.tpp"
#endif