MultiComponentFluidProperties.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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"
#include "SinglePhaseFluidProperties.h"
 
class MultiComponentFluidProperties;
 
template <>
InputParameters validParams<MultiComponentFluidProperties>();
 
#define propfunc(want, prop1, prop2, prop3)                                                        \
  virtual Real want##_from_##prop1##_##prop2##_##prop3(Real, Real, Real) const                     \
  {                                                                                                \
    mooseError(name(), ": ", __PRETTY_FUNCTION__, " not implemented.");                            \
  }                                                                                                \
                                                                                                   \
  virtual void want##_from_##prop1##_##prop2##_##prop3(Real prop1,                                 \
                                                       Real prop2,                                 \
                                                       Real prop3,                                 \
                                                       Real & val,                                 \
                                                       Real & d##want##d1,                         \
                                                       Real & d##want##d2,                         \
                                                       Real & d##want##d3) const                   \
  {                                                                                                \
    if (_allow_imperfect_jacobians)                                                                \
      mooseWarning(name(), ": ", __PRETTY_FUNCTION__, " derivatives not implemented.");            \
    else                                                                                           \
      mooseError(name(), ": ", __PRETTY_FUNCTION__, " derivatives not implemented.");              \
                                                                                                   \
    d##want##d1 = 0.0;                                                                             \
    d##want##d2 = 0.0;                                                                             \
    d##want##d3 = 0.0;                                                                             \
    val = want##_from_##prop1##_##prop2##_##prop3(prop1, prop2, prop3);                            \
  }                                                                                                \
                                                                                                   \
  DualReal want##_from_##prop1##_##prop2##_##prop3(                                                \
      const DualReal & p1, const DualReal & p2, const DualReal & p3) const                         \
  {                                                                                                \
    const Real raw1 = p1.value();                                                                  \
    const Real raw2 = p2.value();                                                                  \
    const Real raw3 = p3.value();                                                                  \
    Real x = 0.0;                                                                                  \
    Real dxd1 = 0.0;                                                                               \
    Real dxd2 = 0.0;                                                                               \
    Real dxd3 = 0.0;                                                                               \
    want##_from_##prop1##_##prop2##_##prop3(raw1, raw2, raw3, x, dxd1, dxd2, dxd3);                \
                                                                                                   \
    DualReal result = x;                                                                           \
    result.derivatives() =                                                                         \
        p1.derivatives() * dxd1 + p2.derivatives() * dxd2 + p3.derivatives() * dxd3;               \
                                                                                                   \
    return result;                                                                                 \
  }
 
class MultiComponentFluidProperties : public FluidProperties
{
public:
  MultiComponentFluidProperties(const InputParameters & parameters);
  virtual ~MultiComponentFluidProperties();
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
  // clang-format off
 
    propfunc(rho, p, T, X)
    propfunc(mu, p, T, X)
    propfunc(h, p, T, X)
    propfunc(cp, p, T, X)
    propfunc(e, p, T, X)
    propfunc(k, p, T, X)
 
  // clang-format on
 
#undef propfunc
#pragma GCC diagnostic pop
 
      virtual std::string fluidName() const;
 
  virtual void
  rho_mu_from_p_T_X(Real pressure, Real temperature, Real xmass, Real & rho, Real & mu) const;
 
  virtual void rho_mu_from_p_T_X(
      DualReal pressure, DualReal temperature, DualReal xmass, DualReal & rho, DualReal & mu) const;
 
  virtual void rho_mu_from_p_T_X(Real pressure,
                                 Real temperature,
                                 Real xmass,
                                 Real & rho,
                                 Real & drho_dp,
                                 Real & drho_dT,
                                 Real & drho_dx,
                                 Real & mu,
                                 Real & dmu_dp,
                                 Real & dmu_dT,
                                 Real & dmu_dx) const;
 
  virtual const SinglePhaseFluidProperties & getComponent(unsigned int component) const;
};