FhInteraction.h

#ifndef PSCF_FH_INTERACTION_H
#define PSCF_FH_INTERACTION_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 <util/containers/DMatrix.h>      // member (template)
#include <util/containers/Matrix.h>       // argument (template)
#include <util/containers/Array.h>        // argument (template)
#include <util/global.h>                  
 
// Forward declaration
namespace Pscf {
   class Interaction;
}
 
namespace Pscf {
 
   using namespace Util;

   class FhInteraction : public ParamComposite
   {
 
   public:

      FhInteraction();

      FhInteraction(FhInteraction const & other);

      FhInteraction(Interaction const & other);

      virtual ~FhInteraction();

      FhInteraction& operator = (FhInteraction const & other);

      FhInteraction& operator = (Interaction const & other);

      void setNMonomer(int nMonomer);

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

      void setChi(Matrix<double> const & chi);

      void setChi(int i, int j, double chi);

      virtual 
      double fHelmholtz(Array<double> const & c) const;

      virtual 
      void computeW(Array<double> const & c, Array<double>& w) 
      const;

      virtual 
      void computeC(Array<double> const & w, Array<double>& c, double& xi)
      const;

      virtual 
      void computeXi(Array<double> const & w, double& xi)
      const;

      virtual 
      void computeDwDc(Array<double> const & c, Matrix<double>& dWdC)
      const;

      Matrix<double> const & chi() const;

      double chi(int i, int j) const;

      double chiInverse(int i, int j) const;

      int nMonomer() const;
 
   private:
 
      // Symmetric matrix of interaction parameters.
      DMatrix<double> chi_;
 
      // Inverse of matrix chi_.
      DMatrix<double> chiInverse_;

      int nMonomer_;

      void updateMembers();
 
      void setChiZero();
 
   };
 
   // Inline function
 
   inline int FhInteraction::nMonomer() const
   {  return nMonomer_; }
 
   inline Matrix<double> const &  FhInteraction::chi() const
   {  return chi_; }
 
   inline double FhInteraction::chi(int i, int j) const
   {  return chi_(i, j); }
 
   inline double FhInteraction::chiInverse(int i, int j) const
   {  return chiInverse_(i, j); }
 
} // namespace Pscf
#endif