pspc/solvers/Mixture.h

#ifndef PSPC_MIXTURE_H
#define PSPC_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 <pscf/chem/Monomer.h>
#include <util/containers/DArray.h>
#include <util/containers/FArray.h>
 
#include <iostream>
 
namespace Pscf { 
   template <int D> class Mesh; 
}
 
namespace Pscf {
namespace Pspc
{
 
   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(const UnitCell<D>& unitCell);
 
      void setKuhn(int monomerId, double kuhn);
 
      void compute(DArray< RField<D> > const & wFields, 
                   DArray< RField<D> >& cFields, 
                   double phiTot = 1.0);
      
      void computeStress();
 
      void createBlockCRGrid(DArray< RField<D> >& blockCFields) const;
 
      double stress(int n) const;
 
      bool isCanonical();
 
      // Inherited public member functions 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:
 
      // Inherited protected member functions with non-dependent names
      using MixtureTmpl< Polymer<D>, Solvent<D> >::setClassName;
      using ParamComposite::read;
      using ParamComposite::readOptional;
 
   private:
 
      double ds_;
 
      FArray<double, 6> stress_;
 
      Mesh<D> const * meshPtr_;
 
      UnitCell<D> const * unitCellPtr_;
 
      Mesh<D> const & mesh() const;
 
      bool hasStress_;
 
   };
 
   // Inline member function
 
   // Stress with respect to unit cell parameter n.
   template <int D>
   inline double Mixture<D>::stress(int n) const
   {
      UTIL_CHECK(hasStress_);  
      return stress_[n]; 
   }
 
   // Get Mesh<D> by constant reference (private).
   template <int D>
   inline Mesh<D> const & Mixture<D>::mesh() const
   {
      UTIL_ASSERT(meshPtr_);
      return *meshPtr_;
   }
 
   #ifndef PSPC_MIXTURE_TPP
   extern template class Mixture<1>;
   extern template class Mixture<2>;
   extern template class Mixture<3>;
   #endif
 
} // namespace Pspc
} // namespace Pscf
#endif