MixtureTmpl.h

#ifndef PSCF_MIXTURE_TMPL_H
#define PSCF_MIXTURE_TMPL_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 <pscf/chem/Monomer.h>
#include <util/param/ParamComposite.h>
#include <util/containers/DArray.h>
 
namespace Pscf
{
 
   using namespace Util;
 
   template <class TP, class TS>
   class MixtureTmpl : public ParamComposite
   {
   public:
 
      // Public typedefs
 
      typedef TP Polymer;
 
      typedef TS Solvent;
 
      // Public member functions
 
      MixtureTmpl();
 
      ~MixtureTmpl();
 
      virtual void readParameters(std::istream& in);
 
 
      Monomer const & monomer(int id) const;
 
      Polymer& polymer(int id);
 
      Polymer const & polymer(int id) const;
 
      Solvent& solvent(int id);
 
      Solvent const & solvent(int id) const;
 
 
      int nMonomer() const;
 
      int nPolymer() const;
 
      int nBlock() const;
 
      int nSolvent() const;
 
      double vMonomer() const;
 
 
   protected:
 
      Monomer& monomer(int id);
 
   private:
 
      DArray<Monomer> monomers_;
 
      DArray<Polymer> polymers_;
 
      DArray<Solvent> solvents_;
 
      int nMonomer_; 
 
      int nPolymer_;
 
      int nSolvent_;
 
      int nBlock_;
 
      double vMonomer_;
 
   };
 
   // Inline member functions
 
   template <class TP, class TS>
   inline int MixtureTmpl<TP,TS>::nMonomer() const
   {  return nMonomer_; }
 
   template <class TP, class TS>
   inline int MixtureTmpl<TP,TS>::nPolymer() const
   {  return nPolymer_; }
 
   template <class TP, class TS>
   inline int MixtureTmpl<TP,TS>::nSolvent() const
   {  return nSolvent_; }
 
   template <class TP, class TS>
   inline int MixtureTmpl<TP,TS>::nBlock() const
   {  return nBlock_; }
 
   template <class TP, class TS>
   inline Monomer const & MixtureTmpl<TP,TS>::monomer(int id) const
   {  
      UTIL_CHECK(id < nMonomer_);
      return monomers_[id]; 
   }
 
   template <class TP, class TS>
   inline Monomer& MixtureTmpl<TP,TS>::monomer(int id)
   {  
      UTIL_CHECK(id < nMonomer_);
      return monomers_[id]; 
   }
 
   template <class TP, class TS>
   inline TP& MixtureTmpl<TP,TS>::polymer(int id)
   {  
      UTIL_CHECK(id < nPolymer_);
      return polymers_[id];
   }
 
   template <class TP, class TS>
   inline TP const & MixtureTmpl<TP,TS>::polymer(int id) const
   {  
      UTIL_CHECK(id < nPolymer_);
      return polymers_[id];
   }
 
   template <class TP, class TS>
   inline TS& MixtureTmpl<TP,TS>::solvent(int id)
   {  
      UTIL_CHECK(id < nSolvent_);
      return solvents_[id]; 
   }
 
   template <class TP, class TS>
   inline TS const & MixtureTmpl<TP,TS>::solvent(int id) const
   {  
      UTIL_CHECK(id < nSolvent_);
      return solvents_[id]; 
   }
 
   template <class TP, class TS>
   inline double MixtureTmpl<TP,TS>::vMonomer() const
   {  return vMonomer_; }
 
   // Non-inline member functions
 
   /*
   * Constructor.
   */
   template <class TP, class TS>
   MixtureTmpl<TP,TS>::MixtureTmpl()
    : ParamComposite(),
      monomers_(),
      polymers_(),
      solvents_(),
      nMonomer_(0), 
      nPolymer_(0),
      nSolvent_(0),
      nBlock_(0),
      vMonomer_(1.0)
   {}
 
   /*
   * Destructor.
   */
   template <class TP, class TS>
   MixtureTmpl<TP,TS>::~MixtureTmpl()
   {}
 
   /*
   * Read all parameters and initialize.
   */
   template <class TP, class TS>
   void MixtureTmpl<TP,TS>::readParameters(std::istream& in)
   {
      // Read nMonomer and monomers array
      read<int>(in, "nMonomer", nMonomer_);
      monomers_.allocate(nMonomer_);
      for (int i = 0; i < nMonomer_; ++i) {
         monomers_[i].setId(i);
      }
      readDArray< Monomer >(in, "monomers", monomers_, nMonomer_);
 
      /*
      * The input format for a single monomer is defined in the istream
      * extraction operation (operator >>) for a Pscf::Monomer, in file
      * pscf/chem/Monomer.cpp. The text representation contains only the
      * value for the monomer statistical segment Monomer::kuhn.
      */
 
      // Read nPolymer
      read<int>(in, "nPolymer", nPolymer_);
      UTIL_CHECK(nPolymer_ > 0);
 
      // Optionally read nSolvent, with nSolvent=0 by default
      nSolvent_ = 0;
      readOptional<int>(in, "nSolvent", nSolvent_);
 
      // Read polymers and compute nBlock
      nBlock_ = 0;
      if (nPolymer_ > 0) {
 
         polymers_.allocate(nPolymer_);
         for (int i = 0; i < nPolymer_; ++i) {
            readParamComposite(in, polymer(i));
            nBlock_ = nBlock_ + polymer(i).nBlock();
         }
   
         // Set statistical segment lengths for all blocks
         double kuhn;
         int monomerId;
         for (int i = 0; i < nPolymer_; ++i) {
            for (int j = 0; j < polymer(i).nBlock(); ++j) {
               monomerId = polymer(i).block(j).monomerId();
               kuhn = monomer(monomerId).kuhn();
               polymer(i).block(j).setKuhn(kuhn);
            }
         }
 
      }
 
      // Read solvents
      if (nSolvent_ > 0) {
 
         solvents_.allocate(nSolvent_);
         for (int i = 0; i < nSolvent_; ++i) {
            readParamComposite(in, solvent(i));
         }
 
      }
 
      // Optionally read monomer reference value
      vMonomer_ = 1.0; // Default value
      readOptional(in, "vMonomer", vMonomer_);
 
   }
 
}
#endif