VaporMixtureFluidProperties.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "FluidProperties.h"
#define propfuncAD(want, prop1, prop2)                                                             \
  virtual ADReal want##_from_##prop1##_##prop2(                                                    \
      const ADReal & p1, const ADReal & p2, const std::vector<ADReal> & x) const                   \
  {                                                                                                \
    Real p1_raw = p1.value();                                                                      \
    Real p2_raw = p2.value();                                                                      \
    std::vector<Real> x_raw(x.size(), 0);                                                          \
    for (unsigned int i = 0; i < x.size(); ++i)                                                    \
      x_raw[i] = x[i].value();                                                                     \
                                                                                                   \
    Real y_raw = 0;                                                                                \
    Real dy_dp1 = 0;                                                                               \
    Real dy_dp2 = 0;                                                                               \
    std::vector<Real> dy_dx(x.size(), 0);                                                          \
    want##_from_##prop1##_##prop2(p1_raw, p2_raw, x_raw, y_raw, dy_dp1, dy_dp2, dy_dx);            \
                                                                                                   \
    ADReal result = y_raw;                                                                         \
    result.derivatives() = p1.derivatives() * dy_dp1 + p2.derivatives() * dy_dp2;                  \
    for (unsigned int i = 0; i < x.size(); ++i)                                                    \
      result.derivatives() += x[i].derivatives() * dy_dx[i];                                       \
    return result;                                                                                 \
  }                                                                                                \
                                                                                                   \
  virtual void want##_from_##prop1##_##prop2(const ADReal & prop1,                                 \
                                             const ADReal & prop2,                                 \
                                             std::vector<ADReal> & x,                              \
                                             ADReal & val,                                         \
                                             ADReal & d##want##d1,                                 \
                                             ADReal & d##want##d2,                                 \
                                             std::vector<ADReal> & d##want##dx) const              \
  {                                                                                                \
    imperfectJacobianMessage(__PRETTY_FUNCTION__, " derivative derivatives not  implemented.");    \
    Real dummy, tmp1, tmp2;                                                                        \
    std::vector<Real> x_raw(x.size(), 0);                                                          \
    std::vector<Real> tmp3(x.size(), 0);                                                           \
    for (unsigned int i = 0; i < x.size(); ++i)                                                    \
      x_raw[i] = x[i].value();                                                                     \
    val = want##_from_##prop1##_##prop2(prop1, prop2, x);                                          \
    want##_from_##prop1##_##prop2(prop1.value(), prop2.value(), x_raw, dummy, tmp1, tmp2, tmp3);   \
    d##want##d1 = tmp1;                                                                            \
    d##want##d2 = tmp2;                                                                            \
    for (unsigned int i = 0; i < x.size(); ++i)                                                    \
      d##want##dx[i] = tmp3[i];                                                                    \
  }
 
#define propfunc(want, prop1, prop2)                                                               \
  virtual Real want##_from_##prop1##_##prop2(Real, Real, const std::vector<Real> &) const          \
  {                                                                                                \
    mooseError(name(), ": ", __PRETTY_FUNCTION__, " not implemented.");                            \
  }                                                                                                \
                                                                                                   \
  virtual void want##_from_##prop1##_##prop2(Real prop1,                                           \
                                             Real prop2,                                           \
                                             const std::vector<Real> & x,                          \
                                             Real & val,                                           \
                                             Real & d##want##d1,                                   \
                                             Real & d##want##d2,                                   \
                                             std::vector<Real> & d##want##dx) const                \
  {                                                                                                \
    imperfectJacobianMessage(__PRETTY_FUNCTION__, " derivatives not implemented.");                \
    d##want##d1 = 0;                                                                               \
    d##want##d2 = 0;                                                                               \
    std::fill(d##want##dx.begin(), d##want##dx.end(), 0.);                                         \
    val = want##_from_##prop1##_##prop2(prop1, prop2, x);                                          \
  }                                                                                                \
                                                                                                   \
  propfuncAD(want, prop1, prop2)
 
class SinglePhaseFluidProperties;
 
class VaporMixtureFluidProperties : public FluidProperties
{
public:
  static InputParameters validParams();
 
  VaporMixtureFluidProperties(const InputParameters & parameters);
  virtual ~VaporMixtureFluidProperties();
 
  virtual const SinglePhaseFluidProperties & getPrimaryFluidProperties() const = 0;
 
  virtual const SinglePhaseFluidProperties &
  getSecondaryFluidProperties(unsigned int i = 0) const = 0;
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
  // clang-format off
 
  propfunc(p, v, e)
  propfunc(T, v, e)
  propfunc(c, v, e)
  propfunc(v, p, T)
  propfunc(rho, p, T)
  propfunc(e, p, T)
  propfunc(s, p, T)
  propfunc(c, p, T)
  propfunc(cp, p, T)
  propfunc(cv, p, T)
  propfunc(mu, p, T)
  propfunc(k, p, T)
  propfunc(e, p, rho)
 
  // clang-format on
 
#undef propfunc
#undef propfuncAD
 
      virtual unsigned int getNumberOfSecondaryVapors() const
  {
    return numberOfComponents() - 1;
  }
 
  virtual unsigned int numberOfComponents() const = 0;
 
  Real primaryMassFraction(const std::vector<Real> & x) const;
 
  Real mixtureMolarMass(const std::vector<Real> & molar_fractions,
                        const std::vector<Real> & molar_masses) const;
 
  std::vector<Real> massFractionsFromMolarFractions(const std::vector<Real> & molar_fractions,
                                                    const std::vector<Real> & molar_masses) const;
 
protected:
  template <typename... Args>
  void imperfectJacobianMessage(Args... args) const
  {
    if (_allow_imperfect_jacobians)
      mooseDoOnce(mooseWarning(std::forward<Args>(args)...));
    else
      mooseError(std::forward<Args>(args)...);
  }
};
 
#pragma GCC diagnostic pop
 
// Macro to avoid compilation issues associated with overloading virtual methods
#define usingVaporMixtureFluidPropertiesMembers                                                    \
  using VaporMixtureFluidProperties::p_from_v_e;                                                   \
  using VaporMixtureFluidProperties::T_from_v_e;                                                   \
  using VaporMixtureFluidProperties::c_from_v_e;                                                   \
  using VaporMixtureFluidProperties::rho_from_p_T;                                                 \
  using VaporMixtureFluidProperties::v_from_p_T;                                                   \
  using VaporMixtureFluidProperties::s_from_p_T;                                                   \
  using VaporMixtureFluidProperties::e_from_p_T;                                                   \
  using VaporMixtureFluidProperties::c_from_p_T;                                                   \
  using VaporMixtureFluidProperties::cp_from_p_T;                                                  \
  using VaporMixtureFluidProperties::cv_from_p_T;                                                  \
  using VaporMixtureFluidProperties::mu_from_p_T;                                                  \
  using VaporMixtureFluidProperties::k_from_p_T;                                                   \
  using VaporMixtureFluidProperties::e_from_p_rho