FhMixture.h

#ifndef PSCF_FH_MIXTURE_H
#define PSCF_FH_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 <util/param/ParamComposite.h>      // base class
 
#include <pscf/chem/Monomer.h>              // member 
#include <pscf/floryHuggins/FhMolecule.h>   // member 
#include <util/containers/DArray.h>         // member 
#include <util/containers/DMatrix.h>        // member 
 
// Forward declarations
namespace Pscf {
   class FhInteraction;
   class LuSolver;
   template <typename WT> class MixtureBase;
}
 
namespace Pscf {
 
   using namespace Util;

   class FhMixture : public ParamComposite
   {
   public:

      FhMixture();

      ~FhMixture();



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

      template <typename WT>
      void initialize(MixtureBase<WT> const& mixture);

      void setNMolecule(int nMolecule);
      
      void setNMonomer(int nMonomer);



      void setComposition(DArray<double> const & phi);

      void computeMu(FhInteraction const & interaction, double xi = 0.0);

      void computePhi(FhInteraction const & interaction, 
                      DArray<double> const & mu, 
                      DArray<double> const & phi, 
                      double&  xi);

      void computeFreeEnergy(FhInteraction const & interaction);


 
      FhMolecule& molecule(int id);

      double mu(int id) const;

      double phi(int id) const;

      double c(int id) const;

      double fHelmholtz() const;

      double pressure() const;

      int nMolecule() const;

      int nMonomer() const;


      void validate() const;
 
   private:

      DArray<FhMolecule> molecules_;

      DArray<double> mu_;

      DArray<double> phi_;

      DArray<double> c_;

      DArray<double> w_;

      DArray<double> residual_;

      DArray<double> dX_;

      DMatrix<double> dWdC_;

      DMatrix<double> dWdPhi_;

      DMatrix<double> jacobian_;

      DArray<double> phiOld_;

      double fHelmholtz_;

      double pressure_;

      LuSolver* solverPtr_;

      int nMolecule_;

      int nMonomer_;

      bool hasComposition_;

      void computeC();

      void adjustXi(DArray<double> const & mu, double& xi); 

      void computeResidual(DArray<double> const & mu,
                           double& error);
 
   };
 
   // Inline member functions
 
   inline FhMolecule& FhMixture::molecule(int id)
   {  
      UTIL_ASSERT(id >= 0);  
      UTIL_ASSERT(id < nMolecule_);  
      return molecules_[id]; 
   }
 
   inline double FhMixture::mu(int id) const
   {  
      UTIL_ASSERT(id >= 0);  
      UTIL_ASSERT(id < nMolecule_);  
      return mu_[id]; 
   }
 
   inline double FhMixture::phi(int id) const
   {
      UTIL_ASSERT(id >= 0);  
      UTIL_ASSERT(id < nMolecule_);  
      return phi_[id]; 
   }
 
   inline double FhMixture::c(int id) const
   {  
      UTIL_ASSERT(id >= 0);  
      UTIL_ASSERT(id < nMonomer_);  
      return c_[id]; 
   }
 
   inline double FhMixture::fHelmholtz() const
   {  return fHelmholtz_; }
 
   inline double FhMixture::pressure() const
   {  return pressure_; }
 
   inline int FhMixture::nMolecule() const
   {  return nMolecule_; }
 
   inline int FhMixture::nMonomer() const
   {  return nMonomer_; }
 
   // Explicit instantiation declaration for member function template
   extern template 
   void FhMixture::initialize<double>(MixtureBase<double> const &);
 
} // namespace Pscf
#endif