pscf/correlation/Mixture.h

#ifndef PSCF_CORRELATION_MIXTURE_H
#define PSCF_CORRELATION_MIXTURE_H
 
/*
* PSCF - Mixture Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <pscf/correlation/Polymer.h>
#include <util/containers/DArray.h>
 
// Forward declarations
namespace Pscf {
   template <typename WT> class MixtureBase;
}
 
namespace Pscf {
namespace Correlation {
 
   using namespace Util;

   template <typename WT>
   class Mixture
   {
 
   public:

      Mixture();

      Mixture(MixtureBase<WT> const & mixture);

      ~Mixture();

      void associate(MixtureBase<WT> const& mixture);

      void allocate();

      void setup();

      void computeOmega(int ma, int mb,
                        Array<double> const & kSq,
                        Array<double> & correlations) const;

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

      Correlation::Polymer<WT> const & polymer(int i) const;

      MixtureBase<WT> const & mixture() const;

      bool isAllocated() const;
 
   private:

      DArray< Correlation::Polymer<WT> > polymers_;

      MixtureBase<WT> const * mixturePtr_;
 
   };
 
   // Get a constituent Correlation::Polymer<WT> object by const reference.
   template <typename WT> inline 
   Correlation::Polymer<WT> const & Mixture<WT>::polymer(int i) const
   {
      UTIL_CHECK(polymers_.isAllocated());
      return polymers_[i];
   }
 
   // Get  a descriptor for the parent mixture by const reference.
   template <typename WT> inline 
   MixtureBase<WT> const & Mixture<WT>::mixture() const
   {  return *mixturePtr_; }
 
   // Has this object been allocated?
   template <typename WT> inline 
   bool Mixture<WT>::isAllocated() const
   {  return polymers_.isAllocated(); }
 
   // Explicit instantiation declaration
   extern template class Mixture<double>;
 
} // namespace Correlation
} // namespace Pscf
#endif