pscf/correlation/Polymer.h

#ifndef PSCF_CORRELATION_POLYMER_H
#define PSCF_CORRELATION_POLYMER_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.
*/
 
// Header includes
#include <util/containers/DArray.h>
#include <util/containers/DMatrix.h>
#include <util/containers/GArray.h>
 
// Forward declarations
namespace Pscf {
   template <typename WT> class PolymerSpecies;
}
 
namespace Pscf {
namespace Correlation {
 
   using namespace Util;

   template <typename WT>
   class Polymer
   {
 
   public:

      Polymer();

      Polymer(PolymerSpecies<WT> const & polymer);

      ~Polymer();

      void associate(PolymerSpecies<WT> const & polymer);

      void allocate(int nMonomer);

      void setup(Array<double> const & kuhn);

      double computeOmega(int ia, int ib, double prefactor, double kSq)
      const;

      void computeOmega(int ia, int ib, double prefactor,
                        Array<double> const & kSq,
                        Array<double> & correlation) const;

      void computeOmegaTotal(double prefactor,
                             Array<double> const & kSq,
                             Array<double> & correlations) const;

      double phi() const;

      double totalLength() const;

      int nBlock() const;

      GArray<int> const & blockIds(int i) const;

      double length(int i) const;

      double rSq(int i, int j) const;
 
   private:
 
      /*
      * Block lengths, indexed by block index.
      *
      * For the thread model, each element contains the length parameter
      * for associated block. For the bead model, each element contains
      * a double precision representation of nBead, the number of beads.
      */
      DArray<double> length_;
 
      /*
      * Monomer statistical segment lengths, indexed by block index.
      */
      DArray<double> kuhn_;
 
      /*
      * Symmetric matrix of values of rSq for paths between blocks.
      *
      * Diagonal elements are zero.
      */
      DMatrix<double> rSq_;
 
      /*
      * Identifiers for blocks of specified monomer type.
      *
      * Elements of the outer DArray are indexed by monomer type id.
      * Each element is a GArray<int> container containing a list of
      * blocks ids for all blocks of the relevant monomer type, if any.
      */
      DArray< GArray<int> > blockIds_;
 
      /*
      * Pointer to the associated PolymerSpecies object.
      */
      PolymerSpecies<WT> const * speciesPtr_;
 
      /*
      * Volume fraction of this polymer.
      */
      double phi_;
 
      /*
      * Sum of lengths of all blocks in the polymer.
      */
      double totalLength_;
 
      /*
      * Number of blocks in this polymer.
      */
      int nBlock_;
 
      /*
      * Number of monomer types in the mixture.
      */
      int nMonomer_;

      PolymerSpecies<WT> const & species() const;
 
   };
 
   // Public inline member functions
 
   // Get the volume fraction of this polymer species.
   template <typename WT> inline
   double Polymer<WT>::phi() const
   {  return phi_; }
 
   // Get the sum of the lengths of all blocks in this polymer species.
   template <typename WT> inline
   double Polymer<WT>::totalLength() const
   {  return totalLength_; }
 
   // Get the number of blocks in this polymer species.
   template <typename WT> inline
   int Polymer<WT>::nBlock() const
   {  return nBlock_; }
 
   // Get the list of blocks ids for a specified monomer type.
   template <typename WT> inline
   GArray<int> const & Polymer<WT>::blockIds(int i) const
   {  return blockIds_[i]; }
 
   // Get the length of a specified block.
   template <typename WT> inline
   double Polymer<WT>::length(int i) const
   {  return length_[i]; }
 
   // Get the mean-squared length of the path connecting two blocks.
   template <typename WT> inline
   double Polymer<WT>::rSq(int i, int j) const
   {  return rSq_(i, j); }
 
   // Private inline member function
 
   // Get the associated PolymerSpecies molecule descriptor object.
   template <typename WT> inline
   PolymerSpecies<WT> const & Polymer<WT>::species() const
   {  return *speciesPtr_; }
 
   // Explicit specialization declaration
   extern template class Polymer<double>;
 
} // namespace Correlation
} // namespace Pscf
#endif