pspg/solvers/Mixture.h

#ifndef PSPG_MIXTURE_H
#define PSPG_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 Pscf {
namespace Pspg
{
 
 
   template <int D>
   class Mixture : public MixtureTmpl< Polymer<D>, Solvent<D> >
   {
 
   public:
 
      Mixture();
 
      ~Mixture();
 
      void readParameters(std::istream& in);
 
      void setMesh(Mesh<D> const & mesh);
 
      void setupUnitCell(UnitCell<D> const & unitCell, 
                         WaveList<D> const & waveList);
 
      void setKuhn(int monomerId, double kuhn);
 
      void 
      compute(DArray< RDField<D> > const & wFields, 
              DArray< RDField<D> > & cFields);
 
      void computeStress(WaveList<D> const & waveList);
 
      void createBlockCRGrid(DArray< RDField<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_;
   
      #if 0 
      double vMonomer_;
      #endif
 
      double ds_;
 
      int nUnitCellParams_;
 
      Mesh<D> const * meshPtr_;
 
      bool hasStress_;
 
      Mesh<D> const & mesh() const;
 
   };
 
   // Inline member function
 
   #if 0
   /*
   * Get monomer reference volume (public).
   */
   template <int D>
   inline double Mixture<D>::vMonomer() const
   {  return vMonomer_; }
   #endif
 
   /*
   * 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 PSPG_MIXTURE_TPP
   // Suppress implicit instantiation
   extern template class Mixture<1>;
   extern template class Mixture<2>;
   extern template class Mixture<3>;
   #endif
 
} // namespace Pspg
} // namespace Pscf
//#include "Mixture.tpp"
#endif