TabulatedFluidProperties.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 "SinglePhaseFluidProperties.h"
#include "DelimitedFileReader.h"

#include "libmesh/utility.h"

class SinglePhaseFluidProperties;
class BidimensionalInterpolation;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"

class TabulatedFluidProperties : public SinglePhaseFluidProperties
{
public:
  static InputParameters validParams();

  TabulatedFluidProperties(const InputParameters & parameters);

  virtual void initialSetup() override;
  virtual void constructInterpolation() = 0;

  virtual std::string fluidName() const override;

  virtual Real molarMass() const override;

  virtual Real rho_from_p_T(Real pressure, Real temperature) const override;

  virtual ADReal rho_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;

  virtual void rho_from_p_T(
      Real pressure, Real temperature, Real & rho, Real & drho_dp, Real & drho_dT) const override;
  virtual void rho_from_p_T(const ADReal & pressure,
                            const ADReal & temperature,
                            ADReal & rho,
                            ADReal & drho_dp,
                            ADReal & drho_dT) const override;

  virtual Real rho_from_p_s(Real p, Real s) const override;
  virtual void
  rho_from_p_s(Real p, Real s, Real & rho, Real & drho_dp, Real & drho_ds) const override;

  virtual Real v_from_p_T(Real pressure, Real temperature) const override;

  virtual ADReal v_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;

  virtual void
  v_from_p_T(Real pressure, Real temperature, Real & v, Real & dv_dp, Real & dv_dT) const override;

  virtual Real e_from_p_T(Real pressure, Real temperature) const override;

  virtual ADReal e_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;

  virtual void
  e_from_p_T(Real pressure, Real temperature, Real & e, Real & de_dp, Real & de_dT) const override;

  virtual Real e_from_p_rho(Real pressure, Real rho) const override;

  virtual ADReal e_from_p_rho(const ADReal & pressure, const ADReal & rho) const override;

  virtual void
  e_from_p_rho(Real pressure, Real rho, Real & e, Real & de_dp, Real & de_drho) const override;

  virtual Real T_from_p_rho(Real pressure, Real rho) const;

  virtual ADReal T_from_p_rho(const ADReal & pressure, const ADReal & rho) const;

  virtual void T_from_p_rho(Real pressure, Real rho, Real & T, Real & dT_dp, Real & dT_drho) const;

  virtual Real h_from_p_T(Real p, Real T) const override;

  virtual ADReal h_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;

  virtual void
  h_from_p_T(Real pressure, Real temperature, Real & h, Real & dh_dp, Real & dh_dT) const override;

  virtual Real mu_from_p_T(Real pressure, Real temperature) const override;

  virtual void mu_from_p_T(
      Real pressure, Real temperature, Real & mu, Real & dmu_dp, Real & dmu_dT) const override;

  virtual Real cp_from_p_T(Real pressure, Real temperature) const override;

  virtual void cp_from_p_T(
      Real pressure, Real temperature, Real & cp, Real & dcp_dp, Real & dcp_dT) const override;

  using SinglePhaseFluidProperties::cp_from_p_T;

  virtual Real cv_from_p_T(Real pressure, Real temperature) const override;
  virtual void cv_from_p_T(
      Real pressure, Real temperature, Real & cv, Real & dcv_dp, Real & dcv_dT) const override;

  virtual Real c_from_p_T(Real pressure, Real temperature) const override;
  virtual void
  c_from_p_T(Real pressure, Real temperature, Real & c, Real & dc_dp, Real & dc_dT) const override;

  virtual Real k_from_p_T(Real pressure, Real temperature) const override;

  virtual void
  k_from_p_T(Real pressure, Real temperature, Real & k, Real & dk_dp, Real & dk_dT) const override;

  virtual Real s_from_p_T(Real pressure, Real temperature) const override;

  virtual void s_from_p_T(Real p, Real T, Real & s, Real & ds_dp, Real & ds_dT) const override;

  virtual std::vector<Real> henryCoefficients() const override;

  virtual Real vaporPressure(Real temperature) const override;

  virtual void vaporPressure(Real temperature, Real & psat, Real & dpsat_dT) const override;

  virtual Real vaporTemperature(Real pressure) const override;
  virtual void vaporTemperature(Real pressure, Real & Tsat, Real & dTsat_dp) const override;

  virtual Real T_from_p_h(Real pressure, Real enthalpy) const override;
  virtual ADReal T_from_p_h(const ADReal & pressure, const ADReal & enthalpy) const override;

  virtual Real triplePointPressure() const override;
  virtual Real triplePointTemperature() const override;
  virtual Real criticalPressure() const override;
  virtual Real criticalTemperature() const override;
  virtual Real criticalDensity() const override;

  virtual Real p_from_v_e(Real v, Real e) const override;
  virtual void p_from_v_e(Real v, Real e, Real & p, Real & dp_dv, Real & dp_de) const override;
  virtual void p_from_v_e(const ADReal & v,
                          const ADReal & e,
                          ADReal & p,
                          ADReal & dp_dv,
                          ADReal & dp_de) const override;
  virtual Real T_from_v_e(Real v, Real e) const override;
  virtual void T_from_v_e(Real v, Real e, Real & T, Real & dT_dv, Real & dT_de) const override;
  virtual void T_from_v_e(const ADReal & v,
                          const ADReal & e,
                          ADReal & p,
                          ADReal & dp_dv,
                          ADReal & dp_de) const override;
  virtual Real c_from_v_e(Real v, Real e) const override;
  virtual void c_from_v_e(Real v, Real e, Real & c, Real & dc_dv, Real & dc_de) const override;
  virtual Real cp_from_v_e(Real v, Real e) const override;
  virtual void cp_from_v_e(Real v, Real e, Real & cp, Real & dcp_dv, Real & dcp_de) const override;
  virtual Real cv_from_v_e(Real v, Real e) const override;
  virtual void cv_from_v_e(Real v, Real e, Real & cv, Real & dcv_dv, Real & dcv_de) const override;
  virtual Real mu_from_v_e(Real v, Real e) const override;
  virtual void mu_from_v_e(Real v, Real e, Real & mu, Real & dmu_dv, Real & dmu_de) const override;
  virtual Real k_from_v_e(Real v, Real e) const override;
  virtual void k_from_v_e(Real v, Real e, Real & k, Real & dk_dv, Real & dk_de) const override;
  virtual Real g_from_v_e(Real v, Real e) const override;
  virtual Real e_from_v_h(Real v, Real h) const override;
  virtual void e_from_v_h(Real v, Real h, Real & e, Real & de_dv, Real & de_dh) const override;
  virtual Real T_from_h_s(Real h, Real s) const;
  virtual Real T_from_p_s(Real p, Real s) const;
  virtual void T_from_p_s(Real p, Real s, Real & T, Real & dT_dp, Real & dT_ds) const;
  virtual Real s_from_v_e(Real v, Real e) const override;
  virtual void s_from_v_e(Real v, Real e, Real & s, Real & ds_dv, Real & ds_de) const override;
  virtual Real s_from_h_p(Real h, Real pressure) const override;
  virtual void
  s_from_h_p(Real h, Real pressure, Real & s, Real & ds_dh, Real & ds_dp) const override;

  using SinglePhaseFluidProperties::c_from_v_e;
  using SinglePhaseFluidProperties::p_from_v_e;
  using SinglePhaseFluidProperties::T_from_v_e;

protected:
  void writeTabulatedData(std::string file_name);

  template <typename T>
  void checkInputVariables(T & pressure, T & temperature) const;

  template <typename T>
  void checkInputVariablesVE(T & v, T & e) const;

  virtual void checkInitialGuess(bool post_reading_tabulation) const;

  void readFileTabulationData(bool use_pT);

  void checkFileTabulationGrids(std::vector<Real> & v1,
                                std::vector<Real> & v2,
                                const std::string & file_name,
                                const std::string & v1_name,
                                const std::string & v2_name);

  virtual void generateTabulatedData();

  virtual void generateVETabulatedData();

  void computePropertyIndicesInInterpolationVectors();

  void createVGridVector();
  void createVEGridVectors();
  void createVHGridVectors();

  void missingVEInterpolationError(const std::string & function_name) const;

  [[noreturn]] void TabulationNotImplementedError(const std::string & desired_routine) const;
  [[noreturn]] void NeedTabulationOrFPError(const std::string & desired_routine,
                                            const std::string & needed_property) const;
  [[noreturn]] void NeedTabulationError(const std::string & needed_property) const;

  FileName _file_name_in;
  FileName _file_name_ve_in;
  FileName _file_name_out;
  FileName _file_name_ve_out;
  const bool _save_file;

  std::vector<Real> _pressure;
  std::vector<Real> _temperature;
  std::vector<Real> _specific_volume;
  std::vector<Real> _internal_energy;
  std::vector<Real> _enthalpy;

  const bool _create_direct_pT_interpolations;
  const bool _create_direct_ve_interpolations;

  std::vector<std::vector<Real>> _properties;
  std::vector<std::vector<Real>> _properties_ve;

  std::vector<std::unique_ptr<BidimensionalInterpolation>> _property_ipol;
  std::vector<std::unique_ptr<BidimensionalInterpolation>> _property_ve_ipol;

  Real _temperature_min;
  Real _temperature_max;
  Real _pressure_min;
  Real _pressure_max;
  unsigned int _num_T;
  unsigned int _num_p;

  const SinglePhaseFluidProperties * const _fp;
  const bool _allow_fp_and_tabulation;

  MultiMooseEnum _interpolated_properties_enum;
  std::vector<std::string> _interpolated_properties;
  bool _interpolate_density;
  bool _interpolate_enthalpy;
  bool _interpolate_internal_energy;
  bool _interpolate_viscosity;
  bool _interpolate_k;
  bool _interpolate_c;
  bool _interpolate_cp;
  bool _interpolate_cv;
  bool _interpolate_entropy;
  bool _interpolate_pressure;
  bool _interpolate_temperature;

  unsigned int _density_idx;
  unsigned int _enthalpy_idx;
  unsigned int _internal_energy_idx;
  unsigned int _viscosity_idx;
  unsigned int _k_idx;
  unsigned int _c_idx;
  unsigned int _cp_idx;
  unsigned int _cv_idx;
  unsigned int _entropy_idx;
  unsigned int _p_idx;
  unsigned int _T_idx;

  MooseUtils::DelimitedFileReader _csv_reader;

  bool _construct_pT_from_ve;
  bool _construct_pT_from_vh;
  bool _initial_setup_done;
  unsigned int _num_v;
  unsigned int _num_e;
  bool _log_space_v;
  bool _log_space_e;
  bool _log_space_h;

  MooseEnum _OOBBehavior;
  enum OOBBehavior
  {
    Ignore,
    Throw,
    DeclareInvalid,
    WarnInvalid,
    SetToClosestBound
  };

  std::unique_ptr<BidimensionalInterpolation> _T_from_v_e_ipol;

  std::unique_ptr<BidimensionalInterpolation> _p_from_v_e_ipol;

  std::unique_ptr<BidimensionalInterpolation> _T_from_v_h_ipol;

  std::unique_ptr<BidimensionalInterpolation> _p_from_v_h_ipol;

  bool _e_bounds_specified;
  bool _v_bounds_specified;
  Real _e_min;
  Real _e_max;
  Real _v_min;
  Real _v_max;
  Real _h_min;
  Real _h_max;
};

#pragma GCC diagnostic pop