rpc/solvers/Mixture.h

#ifndef RPC_MIXTURE_H
#define RPC_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 Prdc {
      namespace Cpu {
         template <int D> class FFT;
         template <int D> class RField;
      }
   }
}
 
namespace Pscf {
namespace Rpc {
 
   using namespace Pscf::Prdc::Cpu;
 
   template <int D>
   class Mixture : public MixtureTmpl< Polymer<D>, Solvent<D> >
   {
 
   public:
 
      Mixture();
 
      ~Mixture();
 
      void readParameters(std::istream& in);
 
      void associate(Mesh<D> const & mesh,
                     FFT<D> const & fft,
                     UnitCell<D> const & cell);
 
      void allocate();
 
      void clearUnitCellData();
 
      void setKuhn(int monomerId, double kuhn);
 
      void compute(DArray< RField<D> > const & wFields, 
                   DArray< RField<D> >& cFields, 
                   double phiTot = 1.0);
      
      void createBlockCRGrid(DArray< RField<D> >& blockCFields) const;
 
      void computeStress(double phiTot = 1.0);
 
      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:
 
      FArray<double, 6> stress_;
 
      double ds_;
 
      Mesh<D> const * meshPtr_;
 
      int nParam_;
 
      bool hasStress_;
 
      // Private function
      
      Mesh<D> const & mesh() const;
 
   };
 
   // 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 RPC_MIXTURE_TPP
   extern template class Mixture<1>;
   extern template class Mixture<2>;
   extern template class Mixture<3>;
   #endif
 
} // namespace Rpc
} // namespace Pscf
#endif