IdealGasMixtureFluidProperties.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 "VaporMixtureFluidProperties.h"
#include "NaNInterface.h"
#include "GasTransportUtils.h"
 
class SinglePhaseFluidProperties;
 
#define override_property(want, prop1, prop2)                                                      \
  template <typename CppType>                                                                      \
  CppType want##_from_##prop1##_##prop2##_templ(                                                   \
      const CppType & prop1, const CppType & prop2, const std::vector<CppType> & x) const;         \
  virtual Real want##_from_##prop1##_##prop2(Real prop1, Real prop2, const std::vector<Real> & x)  \
      const override;                                                                              \
  virtual ADReal want##_from_##prop1##_##prop2(                                                    \
      const ADReal & prop1, const ADReal & prop2, const std::vector<ADReal> & x) const override
 
class IdealGasMixtureFluidProperties : public VaporMixtureFluidProperties, public NaNInterface
{
public:
  static InputParameters validParams();
 
  IdealGasMixtureFluidProperties(const InputParameters & parameters);
 
  usingVaporMixtureFluidPropertiesMembers;
 
  virtual unsigned int numberOfComponents() const override { return _n_components; }
 
  virtual const SinglePhaseFluidProperties & getPrimaryFluidProperties() const override;
  virtual const SinglePhaseFluidProperties &
  getSecondaryFluidProperties(unsigned int i = 0) const override;
 
  template <typename CppType>
  std::vector<CppType>
  secondaryToAllMassFractions_templ(const std::vector<CppType> & x_secondary) const;
  std::vector<ADReal> secondaryToAllMassFractions(const std::vector<ADReal> & x_secondary) const;
  std::vector<Real> secondaryToAllMassFractions(const std::vector<Real> & x_secondary) const;
 
  template <typename CppType>
  CppType mixtureSpecificHeatRatio_templ(const CppType & p,
                                         const CppType & T,
                                         const std::vector<CppType> & x) const;
  ADReal
  mixtureSpecificHeatRatio(const ADReal & p, const ADReal & T, const std::vector<ADReal> & x) const;
  Real mixtureSpecificHeatRatio(Real p, Real T, const std::vector<Real> & x) const;
 
  ADReal mixtureSpecificHeatRatio(const std::vector<ADReal> & x) const;
  Real mixtureSpecificHeatRatio(const std::vector<Real> & x) const;
 
  template <typename CppType>
  CppType mixtureMolarMass_templ(const std::vector<CppType> & x) const;
  ADReal mixtureMolarMass(const std::vector<ADReal> & x) const;
  Real mixtureMolarMass(const std::vector<Real> & x) const;
 
  template <typename CppType>
  std::vector<CppType> molarFractionsFromMassFractions_templ(const std::vector<CppType> & x) const;
  std::vector<ADReal> molarFractionsFromMassFractions(const std::vector<ADReal> & x) const;
  std::vector<Real> molarFractionsFromMassFractions(const std::vector<Real> & x) const;
 
  override_property(p, v, e);
  override_property(T, v, e);
  override_property(v, p, T);
  override_property(rho, p, T);
  override_property(e, p, T);
  override_property(s, p, T);
  override_property(c, p, T);
  override_property(cp, p, T);
  override_property(cv, p, T);
  override_property(mu, p, T);
  override_property(k, p, T);
  override_property(e, p, rho);
 
#undef override_property
 
  virtual Real
  binaryDiffusionCoefficient(Real p, Real T, unsigned int i, unsigned int j) const override;
  virtual ADReal binaryDiffusionCoefficient(const ADReal & p,
                                            const ADReal & T,
                                            unsigned int i,
                                            unsigned int j) const override;
 
protected:
  const std::vector<UserObjectName> _component_fp_names;
  const unsigned int _n_components;
  const unsigned int _n_secondary_components;
 
  std::vector<const SinglePhaseFluidProperties *> _component_fps;
  std::vector<const GasTransportUtils::LennardJonesParameters *> _lennard_jones;
 
  bool _constant_specific_heats;
  Real _T_newton_start;
 
  enum class TransportMixingRule
  {
    MOLE_FRACTION_AVERAGE,
    WILKE
  };
  const TransportMixingRule _transport_mixing_rule;
  std::vector<std::vector<Real>> _wilke_molar_mass_factor;
  std::vector<std::vector<Real>> _wilke_normalization;
 
private:
  template <typename CppType>
  CppType mixTransportProperty(const std::vector<CppType> & psi,
                               const std::vector<CppType> & y,
                               const std::vector<CppType> & mu) const;
 
  template <typename CppType>
  CppType binaryDiffusionCoefficient_templ(const CppType & p,
                                           const CppType & T,
                                           unsigned int i,
                                           unsigned int j) const;
 
  template <typename CppType>
  CppType constantSpecificHeatRatio(const std::vector<CppType> & x) const;
};