TabulatedBicubicFluidPropertiesTest.C

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
 
#include "TabulatedBicubicFluidPropertiesTest.h"
#include "SinglePhaseFluidPropertiesTestUtils.h"
#include "SinglePhaseFluidProperties.h"
#include "CheckNaNsTabulatedFluidProperties.h"
 
#include <fstream>
 
// Test data for unordered data
TEST_F(TabulatedBicubicFluidPropertiesTest, unorderedData)
{
  try
  {
    // Must cast away const to call initialSetup(), where the file is
    // checked for consistency
    const_cast<TabulatedBicubicFluidProperties *>(_unordered_fp)->initialSetup();
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("The column data for temperature is not monotonically increasing");
    ASSERT_TRUE(pos != std::string::npos);
  }
}
 
// Test data for different temperatures ranges in pressure data
TEST_F(TabulatedBicubicFluidPropertiesTest, unequalTemperatures)
{
  try
  {
    const_cast<TabulatedBicubicFluidProperties *>(_unequal_fp)->initialSetup();
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("temperature values for pressure 2e+06 are not "
                                "identical to values for 1e+06");
    ASSERT_TRUE(pos != std::string::npos);
  }
}
 
// Test data for missing column
TEST_F(TabulatedBicubicFluidPropertiesTest, missingColumn)
{
  try
  {
    const auto tow = Moose::_throw_on_warning;
    Moose::_throw_on_warning = true;
    const_cast<TabulatedBicubicFluidProperties *>(_missing_col_fp)->initialSetup();
    Moose::_throw_on_warning = tow;
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("data/csv/missing_col_fluid_props.csv. A "
                                "column named temperature must be present");
    ASSERT_TRUE(pos != std::string::npos);
  }
}
 
// Test data for unknown property column
TEST_F(TabulatedBicubicFluidPropertiesTest, unknownColumn)
{
  try
  {
    const_cast<TabulatedBicubicFluidProperties *>(_unknown_col_fp)->initialSetup();
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("data/csv/unknown_fluid_props.csv tabulation file is not one of "
                                "the properties that TabulatedFluidProperties understands");
    ASSERT_TRUE(pos != std::string::npos);
  }
}
 
// Test data for missing data
TEST_F(TabulatedBicubicFluidPropertiesTest, missingData)
{
  try
  {
    const_cast<TabulatedBicubicFluidProperties *>(_missing_data_fp)->initialSetup();
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("data/csv/missing_data_fluid_props.csv "
                                "is not equal to the number of unique pressure values 3 multiplied "
                                "by the number of unique temperature values 3");
    ASSERT_TRUE(pos != std::string::npos);
  }
}
 
// Test tabulated fluid properties read from file including comments
TEST_F(TabulatedBicubicFluidPropertiesTest, fromPTFile)
{
  Real p = 1.5e6;
  Real T = 450.0;
 
  // Read the data file
  const_cast<TabulatedBicubicFluidProperties *>(_tab_pT_from_fp)->initialSetup();
 
  // Fluid properties
  REL_TEST(_tab_pT_from_fp->rho_from_p_T(p, T), _co2_fp->rho_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->h_from_p_T(p, T), _co2_fp->h_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->e_from_p_T(p, T), _co2_fp->e_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->mu_from_p_T(p, T), _co2_fp->mu_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->k_from_p_T(p, T), _co2_fp->k_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->cp_from_p_T(p, T), _co2_fp->cp_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->cv_from_p_T(p, T), _co2_fp->cv_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp->s_from_p_T(p, T), _co2_fp->s_from_p_T(p, T), 1.0e-4);
 
  // Fluid properties and derivatives
  Real rho, drho_dp, drho_dT, rhoc, drhoc_dp, drhoc_dT;
  _tab_pT_from_fp->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
  _co2_fp->rho_from_p_T(p, T, rhoc, drhoc_dp, drhoc_dT);
  REL_TEST(rho, rhoc, 1.0e-4);
  REL_TEST(drho_dp, drhoc_dp, 1.0e-3);
  REL_TEST(drho_dT, drhoc_dT, 1.0e-3);
 
  Real h, dh_dp, dh_dT, hc, dhc_dp, dhc_dT;
  _tab_pT_from_fp->h_from_p_T(p, T, h, dh_dp, dh_dT);
  _co2_fp->h_from_p_T(p, T, hc, dhc_dp, dhc_dT);
  REL_TEST(h, hc, 1.0e-4);
  REL_TEST(dh_dp, dhc_dp, 1.0e-3);
  REL_TEST(dh_dT, dhc_dT, 1.0e-3);
 
  Real mu, dmu_dp, dmu_dT, muc, dmuc_dp, dmuc_dT;
  _tab_pT_from_fp->mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
  _co2_fp->mu_from_p_T(p, T, muc, dmuc_dp, dmuc_dT);
  REL_TEST(mu, muc, 1.0e-4);
  REL_TEST(dmu_dp, dmuc_dp, 1.0e-3);
  REL_TEST(dmu_dT, dmuc_dT, 1.0e-3);
 
  Real k, dk_dp, dk_dT, kc, dkc_dp, dkc_dT;
  _tab_pT_from_fp->k_from_p_T(p, T, k, dk_dp, dk_dT);
  _co2_fp->k_from_p_T(p, T, kc, dkc_dp, dkc_dT);
  REL_TEST(k, kc, 1.0e-4);
  REL_TEST(dk_dp, dkc_dp, 1.0e-3);
  REL_TEST(dk_dT, dkc_dT, 1.0e-3);
 
  Real e, de_dp, de_dT, ec, dec_dp, dec_dT;
  _tab_pT_from_fp->e_from_p_T(p, T, e, de_dp, de_dT);
  _co2_fp->e_from_p_T(p, T, ec, dec_dp, dec_dT);
  REL_TEST(e, ec, 1.0e-4);
  REL_TEST(de_dp, dec_dp, 1.0e-3);
  REL_TEST(de_dT, dec_dT, 1.0e-3);
 
  Real s, ds_dp, ds_dT, sc, dsc_dp, dsc_dT;
  _tab_pT_from_fp->s_from_p_T(p, T, s, ds_dp, ds_dT);
  _co2_fp->s_from_p_T(p, T, sc, dsc_dp, dsc_dT);
  REL_TEST(s, sc, 1.0e-4);
  REL_TEST(ds_dp, dsc_dp, 1.0e-3);
  REL_TEST(ds_dT, dsc_dT, 1.0e-3);
}
 
// Test tabulated fluid properties read from file including comments
TEST_F(TabulatedBicubicFluidPropertiesTest, fromPTFileToVE)
{
  Real p = 1.5e6;
  Real T = 450.0;
  Real pert = 1.0e-7;
 
  // Read the data file
  Moose::_throw_on_warning = false;
  const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_pT)->initialSetup();
  Moose::_throw_on_warning = true;
 
  // round trip p,T -> v,e -> p,T
  {
    Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
    Real pp = _tab_ve_from_pT->p_from_v_e(v, e);
    Real TT = _tab_ve_from_pT->T_from_v_e(v, e);
    ABS_TEST(T, TT, 1.0);
    REL_TEST(p, pp, 0.001);
  }
 
  // check computation of fluid props from p, T & v, e
  {
    Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
 
    // heat capacity at constant pressure
    Real cp1 = _tab_ve_from_pT->cp_from_p_T(p, T);
    Real cp2 = _tab_ve_from_pT->cp_from_v_e(v, e);
    REL_TEST(cp1, cp2, 0.001);
 
    // heat capacity at constant volume
    Real cv1 = _tab_ve_from_pT->cv_from_p_T(p, T);
    Real cv2 = _tab_ve_from_pT->cv_from_v_e(v, e);
    REL_TEST(cv1, cv2, 0.001);
 
    // viscosity
    Real mu1 = _tab_ve_from_pT->mu_from_p_T(p, T);
    Real mu2 = _tab_ve_from_pT->mu_from_v_e(v, e);
    REL_TEST(mu1, mu2, 0.001);
 
    // thermal conductivity
    Real k1 = _tab_ve_from_pT->k_from_p_T(p, T);
    Real k2 = _tab_ve_from_pT->k_from_v_e(v, e);
    REL_TEST(k1, k2, 0.001);
 
    // enthalpy
    Real h1 = _tab_ve_from_pT->h_from_p_T(p, T);
    Real h2 = _tab_ve_from_pT->h_from_v_e(v, e);
    REL_TEST(h1, h2, 0.001);
 
    // entropy
    Real s1 = _tab_ve_from_pT->s_from_p_T(p, T);
    Real s2 = _tab_ve_from_pT->s_from_v_e(v, e);
    REL_TEST(s1, s2, 0.001);
 
    // Gibbs free energy from the (p, T) from (v, e) interpolations
    REL_TEST(_tab_ve_from_pT->g_from_v_e(v, e), h1 - T * s1, 0.001);
 
    // entropy derivatives from the (p, T) from (v, e) interpolations: de = T ds - p dv
    Real s3, ds_dv, ds_de;
    _tab_ve_from_pT->s_from_v_e(v, e, s3, ds_dv, ds_de);
    REL_TEST(s3, s2, REL_TOL_CONSISTENCY);
    REL_TEST(ds_de, 1.0 / T, 0.01);
    REL_TEST(ds_dv, p / T, 0.01);
  }
 
  // check computation of fluid props from p, s
  {
    Real s = _tab_ve_from_pT->s_from_p_T(p, T);
 
    // density
    Real rho1 = _tab_ve_from_pT->rho_from_p_T(p, T);
    Real rho2 = _tab_ve_from_pT->rho_from_p_s(p, s);
    REL_TEST(rho1, rho2, 0.001);
 
    // temperature
    Real Ts = _tab_ve_from_pT->T_from_p_s(p, s);
    REL_TEST(T, Ts, 0.001);
  }
 
  // check computation of fluid props from p, rho
  {
    Real rho = _tab_ve_from_pT->rho_from_p_T(p, T);
 
    // specific internal energy
    Real e1 = _tab_ve_from_pT->e_from_p_T(p, T);
    Real e2 = _tab_ve_from_pT->e_from_p_rho(p, rho);
    REL_TEST(e1, e2, REL_TOL_CONSISTENCY);
  }
 
  // check computation of fluids props from p, h
  {
    Real T = 450;
    Real p = 1.5e6;
    Real h = _tab_ve_from_pT->h_from_p_T(p, T);
    Real Ts = _tab_ve_from_pT->T_from_p_h(p, h);
    REL_TEST(T, Ts, 1e-4);
 
    // to keep coverage on the default definition in SinglePhaseFP
    Ts = dynamic_cast<const SinglePhaseFluidProperties *>(_tab_ve_from_pT)->T_from_p_h(p, h);
    REL_TEST(T, Ts, 1e-4);
  }
 
  // are the two version of functions equivalent
  {
    Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
 
    Real d1, d2;
 
    // speed of sound errors bc co2 props don't
    // implement enough
 
    // heat capacity at constant pressure
    Real cp1;
    _tab_ve_from_pT->cp_from_v_e(v, e, cp1, d1, d2);
    Real cp2 = _tab_ve_from_pT->cp_from_v_e(v, e);
    REL_TEST(cp1, cp2, 0.001);
 
    // heat capacity at constant volume
    Real cv1;
    _tab_ve_from_pT->cv_from_v_e(v, e, cv1, d1, d2);
    Real cv2 = _tab_ve_from_pT->cv_from_v_e(v, e);
    REL_TEST(cv1, cv2, 0.001);
 
    // viscosity
    Real mu1;
    _tab_ve_from_pT->mu_from_v_e(v, e, mu1, d1, d2);
    Real mu2 = _tab_ve_from_pT->mu_from_v_e(v, e);
    REL_TEST(mu1, mu2, 0.001);
 
    // thermal conductivity
    Real k1;
    _tab_ve_from_pT->k_from_v_e(v, e, k1, d1, d2);
    Real k2 = _tab_ve_from_pT->k_from_v_e(v, e);
    REL_TEST(k1, k2, 0.001);
  }
 
  // check derivatives
  {
    Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
 
    Real deriv1, deriv2;
 
    // pressure
    Real p1;
    _tab_ve_from_pT->p_from_v_e(v, e, p1, deriv1, deriv2);
    Real p2 = _tab_ve_from_pT->p_from_v_e(v, e);
    REL_TEST(p1, p2, 0.001);
 
    // temperature
    Real T1;
    _tab_ve_from_pT->T_from_v_e(v, e, T1, deriv1, deriv2);
    Real T2 = _tab_ve_from_pT->T_from_v_e(v, e);
    REL_TEST(T1, T2, 0.001);
 
    // speed of sound errors bc co2 props don't
    // implement enough
 
    // heat capacity at constant pressure
    Real cp1;
    _tab_ve_from_pT->cp_from_v_e(v, e, cp1, deriv1, deriv2);
    Real cp_0 = _tab_ve_from_pT->cp_from_v_e(v, e);
    Real cp_1 = _tab_ve_from_pT->cp_from_v_e(v * (1 + pert), e);
    Real cp_2 = _tab_ve_from_pT->cp_from_v_e(v, e * (1 + pert));
    REL_TEST(deriv1, (cp_1 - cp_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (cp_2 - cp_0) / (e * pert), 0.001);
 
    // heat capacity at constant volume
    Real cv1;
    _tab_ve_from_pT->cv_from_v_e(v, e, cv1, deriv1, deriv2);
    Real cv_0 = _tab_ve_from_pT->cv_from_v_e(v, e);
    Real cv_1 = _tab_ve_from_pT->cv_from_v_e(v * (1 + pert), e);
    Real cv_2 = _tab_ve_from_pT->cv_from_v_e(v, e * (1 + pert));
    REL_TEST(deriv1, (cv_1 - cv_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (cv_2 - cv_0) / (e * pert), 0.001);
 
    // viscosity
    Real mu1;
    _tab_ve_from_pT->mu_from_v_e(v, e, mu1, deriv1, deriv2);
    Real mu_0 = _tab_ve_from_pT->mu_from_v_e(v, e);
    Real mu_1 = _tab_ve_from_pT->mu_from_v_e(v * (1 + pert), e);
    Real mu_2 = _tab_ve_from_pT->mu_from_v_e(v, e * (1 + pert));
    REL_TEST(deriv1, (mu_1 - mu_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (mu_2 - mu_0) / (e * pert), 0.001);
 
    // thermal conductivity
    Real k1;
    _tab_ve_from_pT->k_from_v_e(v, e, k1, deriv1, deriv2);
    Real k_0 = _tab_ve_from_pT->k_from_v_e(v, e);
    Real k_1 = _tab_ve_from_pT->k_from_v_e(v * (1 + pert), e);
    Real k_2 = _tab_ve_from_pT->k_from_v_e(v, e * (1 + pert));
    REL_TEST(deriv1, (k_1 - k_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (k_2 - k_0) / (e * pert), 0.001);
  }
 
  // test enthalpy relationships
  {
    Real h = _tab_ve_from_pT->h_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
    Real e_gold = _tab_ve_from_pT->e_from_p_T(p, T);
    Real e = _tab_ve_from_pT->e_from_v_h(v, h);
    REL_TEST(e_gold, e, 0.001);
 
    Real e2, de_dv, de_dh;
    _tab_ve_from_pT->e_from_v_h(v, h, e2, de_dv, de_dh);
    REL_TEST(e_gold, e2, 0.001);
    Real e_0 = _tab_ve_from_pT->e_from_v_h(v, h);
    Real e_1 = _tab_ve_from_pT->e_from_v_h(v * (1 + pert), h);
    Real e_2 = _tab_ve_from_pT->e_from_v_h(v, h * (1 + pert));
    REL_TEST(de_dv, (e_1 - e_0) / (v * pert), 0.001);
    REL_TEST(de_dh, (e_2 - e_0) / (h * pert), 0.001);
  }
 
  // AD p_from_v_e
  {
    Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
    DNDerivativeType dvdx;
    DNDerivativeType dedx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dvdx, 0, 1);
    Moose::derivInsert(dvdx, 1, 0);
    Moose::derivInsert(dedx, 0, 0);
    Moose::derivInsert(dedx, 1, 1);
 
    ADReal v_ad(v, dvdx);
    ADReal e_ad(e, dedx);
    ADReal p_ad = _tab_ve_from_pT->p_from_v_e(v_ad, e_ad);
 
    Real pp, dp_dv, dp_de;
    _tab_ve_from_pT->p_from_v_e(v, e, pp, dp_dv, dp_de);
    REL_TEST(p_ad.derivatives()[0], dp_dv, 0.0001);
    REL_TEST(p_ad.derivatives()[1], dp_de, 0.0001);
 
    ADReal ad_pp, ad_dp_dv, ad_dp_de;
    _tab_ve_from_pT->p_from_v_e(v_ad, e_ad, ad_pp, ad_dp_dv, ad_dp_de);
    REL_TEST(p_ad.derivatives()[0], ad_dp_dv.value(), 0.0001);
    REL_TEST(p_ad.derivatives()[1], ad_dp_de.value(), 0.0001);
  }
 
  // AD T_from_v_e
  {
    Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    Real v = _tab_ve_from_pT->v_from_p_T(p, T);
    DNDerivativeType dvdx;
    DNDerivativeType dedx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dvdx, 0, 1);
    Moose::derivInsert(dvdx, 1, 0);
    Moose::derivInsert(dedx, 0, 0);
    Moose::derivInsert(dedx, 1, 1);
 
    ADReal v_ad(v, dvdx);
    ADReal e_ad(e, dedx);
    ADReal T_ad = _tab_ve_from_pT->T_from_v_e(v_ad, e_ad);
 
    Real TT, dT_dv, dT_de;
    _tab_ve_from_pT->T_from_v_e(v, e, TT, dT_dv, dT_de);
    REL_TEST(T_ad.derivatives()[0], dT_dv, 0.0001);
    REL_TEST(T_ad.derivatives()[1], dT_de, 0.0001);
 
    ADReal ad_TT, ad_dT_dv, ad_dT_de;
    _tab_ve_from_pT->T_from_v_e(v_ad, e_ad, ad_TT, ad_dT_dv, ad_dT_de);
    REL_TEST(T_ad.derivatives()[0], ad_dT_dv.value(), 0.0001);
    REL_TEST(T_ad.derivatives()[1], ad_dT_de.value(), 0.0001);
  }
 
  // cannot test AD c_from_v_e because co2 props do not
  // implement enough
 
  // AD T_from_p_h
  {
    Real h = _tab_ve_from_pT->h_from_p_T(p, T);
    DNDerivativeType dpdx;
    DNDerivativeType dhdx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(dhdx, 0, 0);
    Moose::derivInsert(dhdx, 1, 1);
 
    ADReal p_ad(p, dpdx);
    ADReal h_ad(h, dhdx);
    ADReal T_ad = _tab_ve_from_pT->T_from_p_h(p_ad, h_ad);
 
    Real TT_1 = _tab_ve_from_pT->T_from_p_h(p * (1 + pert), h);
    Real TT_2 = _tab_ve_from_pT->T_from_p_h(p, h * (1 + pert));
    Real dT_dp = (TT_1 - T) / p / pert;
    Real dT_dh = (TT_2 - T) / h / pert;
    REL_TEST(T_ad.derivatives()[0], dT_dp, 0.0001);
    REL_TEST(T_ad.derivatives()[1], dT_dh, 0.0001);
  }
 
  // AD rho_from_p_T
  {
    DNDerivativeType dpdx;
    DNDerivativeType dTdx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(dTdx, 0, 0);
    Moose::derivInsert(dTdx, 1, 1);
 
    ADReal p_ad(p, dpdx);
    ADReal T_ad(T, dTdx);
    ADReal rho_ad = _tab_ve_from_pT->rho_from_p_T(p_ad, T_ad);
 
    Real rho, drho_dp, drho_dT;
    _tab_ve_from_pT->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
    REL_TEST(rho_ad.derivatives()[0], drho_dp, 0.0001);
    REL_TEST(rho_ad.derivatives()[1], drho_dT, 0.0001);
 
    ADReal ad_rho, ad_drho_dp, ad_drho_dT;
    _tab_ve_from_pT->rho_from_p_T(p_ad, T_ad, ad_rho, ad_drho_dp, ad_drho_dT);
    REL_TEST(rho_ad.derivatives()[0], ad_drho_dp.value(), 0.0001);
    REL_TEST(rho_ad.derivatives()[1], ad_drho_dT.value(), 0.0001);
  }
 
  // AD e_from_p_T
  {
    DNDerivativeType dpdx;
    DNDerivativeType dTdx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(dTdx, 0, 0);
    Moose::derivInsert(dTdx, 1, 1);
 
    ADReal p_ad(p, dpdx);
    ADReal T_ad(T, dTdx);
    ADReal e_ad = _tab_ve_from_pT->e_from_p_T(p_ad, T_ad);
 
    Real e, de_dp, de_dT;
    _tab_ve_from_pT->e_from_p_T(p, T, e, de_dp, de_dT);
    REL_TEST(e_ad.derivatives()[0], de_dp, 0.0001);
    REL_TEST(e_ad.derivatives()[1], de_dT, 0.0001);
  }
 
  // AD v_from_p_T
  {
    DNDerivativeType dpdx;
    DNDerivativeType dTdx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(dTdx, 0, 0);
    Moose::derivInsert(dTdx, 1, 1);
 
    ADReal p_ad(p, dpdx);
    ADReal T_ad(T, dTdx);
    ADReal v_ad = _tab_ve_from_pT->v_from_p_T(p_ad, T_ad);
 
    Real v, dv_dp, dv_dT;
    _tab_ve_from_pT->v_from_p_T(p, T, v, dv_dp, dv_dT);
    REL_TEST(v_ad.derivatives()[0], dv_dp, 0.0001);
    REL_TEST(v_ad.derivatives()[1], dv_dT, 0.0001);
  }
}
 
// Test tabulated fluid properties read from file including comments
TEST_F(TabulatedBicubicFluidPropertiesTest, fromVEGeneratedFromFP)
{
  // These values must be within the bounds specified in the header
  Real p = 1.223e6;
  Real T = 420.1;
  Real pert = 1.0e-7;
 
  // Generate the (v, e) tabulation from the FP user object
  const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_fp)->initialSetup();
 
  // Use as a reference
  Real e = _idg_fp->e_from_p_T(p, T);
  Real v = _idg_fp->v_from_p_T(p, T);
 
  // check computation of fluid props from v, e
  {
    // heat capacity at constant pressure
    Real cp1 = _idg_fp->cp_from_v_e(v, e);
    Real cp2 = _tab_ve_from_fp->cp_from_v_e(v, e);
    REL_TEST(cp1, cp2, 0.001);
 
    // heat capacity at constant volume
    Real cv1 = _idg_fp->cv_from_v_e(v, e);
    Real cv2 = _tab_ve_from_fp->cv_from_v_e(v, e);
    REL_TEST(cv1, cv2, 0.001);
 
    // speed of sound
    Real c1 = _idg_fp->c_from_v_e(v, e);
    Real c2 = _tab_ve_from_fp->c_from_v_e(v, e);
    REL_TEST(c1, c2, 0.001);
 
    // viscosity
    Real mu1 = _idg_fp->mu_from_v_e(v, e);
    Real mu2 = _tab_ve_from_fp->mu_from_v_e(v, e);
    REL_TEST(mu1, mu2, 0.001);
 
    // thermal conductivity
    Real k1 = _idg_fp->k_from_v_e(v, e);
    Real k2 = _tab_ve_from_fp->k_from_v_e(v, e);
    REL_TEST(k1, k2, 0.001);
  }
 
  // are the two version of functions equivalent
  {
    Real d1, d2;
 
    // pressure
    Real p1;
    _tab_ve_from_fp->p_from_v_e(v, e, p1, d1, d2);
    Real p2 = _tab_ve_from_fp->p_from_v_e(v, e);
    REL_TEST(p1, p2, 0.001);
 
    // temperature
    Real T1;
    _tab_ve_from_fp->T_from_v_e(v, e, T1, d1, d2);
    Real T2 = _tab_ve_from_fp->T_from_v_e(v, e);
    REL_TEST(T1, T2, 0.001);
 
    // heat capacity at constant pressure
    Real cp1;
    _tab_ve_from_fp->cp_from_v_e(v, e, cp1, d1, d2);
    Real cp2 = _tab_ve_from_fp->cp_from_v_e(v, e);
    REL_TEST(cp1, cp2, 0.001);
 
    // heat capacity at constant volume
    Real cv1;
    _tab_ve_from_fp->cv_from_v_e(v, e, cv1, d1, d2);
    Real cv2 = _tab_ve_from_fp->cv_from_v_e(v, e);
    REL_TEST(cv1, cv2, 0.001);
 
    // speed of sound
    Real c1;
    _tab_ve_from_fp->c_from_v_e(v, e, c1, d1, d2);
    Real c2 = _tab_ve_from_fp->c_from_v_e(v, e);
    REL_TEST(c1, c2, 0.001);
 
    // viscosity
    Real mu1;
    _tab_ve_from_fp->mu_from_v_e(v, e, mu1, d1, d2);
    Real mu2 = _tab_ve_from_fp->mu_from_v_e(v, e);
    REL_TEST(mu1, mu2, 0.001);
 
    // thermal conductivity
    Real k1;
    _tab_ve_from_fp->k_from_v_e(v, e, k1, d1, d2);
    Real k2 = _tab_ve_from_fp->k_from_v_e(v, e);
    REL_TEST(k1, k2, 0.001);
  }
 
  // check derivatives
  {
    Real deriv1, deriv2;
 
    // speed of sound errors bc co2 props don't
    // implement enough
 
    // heat capacity at constant pressure
    Real cp1;
    _tab_ve_from_fp->cp_from_v_e(v, e, cp1, deriv1, deriv2);
    Real cp_0 = _tab_ve_from_fp->cp_from_v_e(v, e);
    Real cp_1 = _tab_ve_from_fp->cp_from_v_e(v * (1 + pert), e);
    Real cp_2 = _tab_ve_from_fp->cp_from_v_e(v, e * (1 + pert));
    REL_TEST(cp1, cp_0, 0.001);
    REL_TEST(deriv1, (cp_1 - cp_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (cp_2 - cp_0) / (e * pert), 0.001);
 
    // heat capacity at constant volume
    Real cv1;
    _tab_ve_from_fp->cv_from_v_e(v, e, cv1, deriv1, deriv2);
    Real cv_0 = _tab_ve_from_fp->cv_from_v_e(v, e);
    Real cv_1 = _tab_ve_from_fp->cv_from_v_e(v * (1 + pert), e);
    Real cv_2 = _tab_ve_from_fp->cv_from_v_e(v, e * (1 + pert));
    REL_TEST(cv1, cv_0, 0.001);
    REL_TEST(deriv1, (cv_1 - cv_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (cv_2 - cv_0) / (e * pert), 0.001);
 
    // viscosity
    Real mu1;
    _tab_ve_from_fp->mu_from_v_e(v, e, mu1, deriv1, deriv2);
    Real mu_0 = _tab_ve_from_fp->mu_from_v_e(v, e);
    Real mu_1 = _tab_ve_from_fp->mu_from_v_e(v * (1 + pert), e);
    Real mu_2 = _tab_ve_from_fp->mu_from_v_e(v, e * (1 + pert));
    REL_TEST(mu1, mu_0, 0.001);
    REL_TEST(deriv1, (mu_1 - mu_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (mu_2 - mu_0) / (e * pert), 0.001);
 
    // thermal conductivity
    Real k1;
    _tab_ve_from_fp->k_from_v_e(v, e, k1, deriv1, deriv2);
    Real k_0 = _tab_ve_from_fp->k_from_v_e(v, e);
    Real k_1 = _tab_ve_from_fp->k_from_v_e(v * (1 + pert), e);
    Real k_2 = _tab_ve_from_fp->k_from_v_e(v, e * (1 + pert));
    REL_TEST(k1, k_0, 0.001);
    REL_TEST(deriv1, (k_1 - k_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (k_2 - k_0) / (e * pert), 0.001);
 
    // entropy
    Real s1;
    _tab_ve_from_fp->s_from_v_e(v, e, s1, deriv1, deriv2);
    Real s_0 = _tab_ve_from_fp->s_from_v_e(v, e);
    Real s_1 = _tab_ve_from_fp->s_from_v_e(v * (1 + pert), e);
    Real s_2 = _tab_ve_from_fp->s_from_v_e(v, e * (1 + pert));
    REL_TEST(s1, s_0, 0.001);
    REL_TEST(deriv1, (s_1 - s_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (s_2 - s_0) / (e * pert), 0.001);
  }
 
  // test enthalpy relationships (v,h)
  {
    Moose::_throw_on_warning = false;
    Real h = _idg_fp->h_from_p_T(p, T);
    Real v = _idg_fp->v_from_p_T(p, T);
    Real e_gold = _idg_fp->e_from_p_T(p, T);
    Real e0 = _tab_ve_from_fp->e_from_v_h(v, h);
    REL_TEST(e_gold, e0, 0.001);
 
    Real e2, de_dv, de_dh;
    _tab_ve_from_fp->e_from_v_h(v, h, e2, de_dv, de_dh);
    REL_TEST(e_gold, e2, 0.001);
    Real e_0 = _tab_ve_from_fp->e_from_v_h(v, h);
    Real e_1 = _tab_ve_from_fp->e_from_v_h(v * (1 + pert), h);
    Real e_2 = _tab_ve_from_fp->e_from_v_h(v, h * (1 + pert));
    REL_TEST(de_dv, (e_1 - e_0) / (v * pert), 0.001);
    REL_TEST(de_dh, (e_2 - e_0) / (h * pert), 0.001);
    Moose::_throw_on_warning = true;
  }
 
  // check computations from p, T
  {
    // density
    Real p = _tab_ve_from_fp->p_from_v_e(v, e);
    Real T = _tab_ve_from_fp->T_from_v_e(v, e);
    REL_TEST(1. / v, _tab_ve_from_fp->rho_from_p_T(p, T), 1e-6);
 
    // internal energy
    REL_TEST(e, _tab_ve_from_fp->e_from_p_T(p, T), 1e-6);
 
    // enthalpy
    Real h = _tab_ve_from_fp->h_from_v_e(v, e);
    REL_TEST(h, _tab_ve_from_fp->h_from_p_T(p, T), 1e-6);
 
    // entropy
    Real s = _tab_ve_from_fp->s_from_v_e(v, e);
    REL_TEST(s, _tab_ve_from_fp->s_from_p_T(p, T), 1e-6);
  }
 
  // check computations from p, rho
  {
    // temperature
    Real p = _tab_ve_from_fp->p_from_v_e(v, e);
    Real T = _tab_ve_from_fp->T_from_v_e(v, e);
    REL_TEST(T, _tab_ve_from_fp->T_from_p_rho(p, 1. / v), 1e-6);
 
    // specific internal energy
    REL_TEST(e, _tab_ve_from_fp->e_from_p_rho(p, 1. / v), 1e-6);
  }
 
  // check computations from p, h
  {
    // temperature
    Real p = _tab_ve_from_fp->p_from_v_e(v, e);
    Real T = _tab_ve_from_fp->T_from_v_e(v, e);
    Real h = _tab_ve_from_fp->h_from_v_e(v, e);
    REL_TEST(T, _tab_ve_from_fp->T_from_p_h(p, h), 1e-6);
 
    // entropy
    Real s = _tab_ve_from_fp->s_from_v_e(v, e);
    REL_TEST(s, _tab_ve_from_fp->s_from_h_p(h, p), 1e-6);
  }
 
  // check computations from p, s
  {
    // temperature
    Real p = _tab_ve_from_fp->p_from_v_e(v, e);
    Real T = _tab_ve_from_fp->T_from_v_e(v, e);
    Real s = _tab_ve_from_fp->s_from_v_e(v, e);
    Moose::_throw_on_warning = false;
    REL_TEST(T, _tab_ve_from_fp->T_from_p_s(p, s), 1e-6);
    Moose::_throw_on_warning = true;
  }
 
  // AD p_from_v_e
  {
    DNDerivativeType dvdx;
    DNDerivativeType dedx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dvdx, 0, 1);
    Moose::derivInsert(dvdx, 1, 0);
    Moose::derivInsert(dedx, 0, 0);
    Moose::derivInsert(dedx, 1, 1);
 
    ADReal v_ad(v, dvdx);
    ADReal e_ad(e, dedx);
    ADReal p_ad = _tab_ve_from_fp->p_from_v_e(v_ad, e_ad);
 
    Real pp, dp_dv, dp_de;
    _tab_ve_from_fp->p_from_v_e(v, e, pp, dp_dv, dp_de);
    REL_TEST(p_ad.derivatives()[0], dp_dv, 0.0001);
    REL_TEST(p_ad.derivatives()[1], dp_de, 0.0001);
  }
 
  // AD T_from_v_e
  {
    DNDerivativeType dvdx;
    DNDerivativeType dedx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dvdx, 0, 1);
    Moose::derivInsert(dvdx, 1, 0);
    Moose::derivInsert(dedx, 0, 0);
    Moose::derivInsert(dedx, 1, 1);
 
    ADReal v_ad(v, dvdx);
    ADReal e_ad(e, dedx);
    ADReal T_ad = _tab_ve_from_fp->T_from_v_e(v_ad, e_ad);
 
    Real TT, dT_dv, dT_de;
    _tab_ve_from_fp->T_from_v_e(v, e, TT, dT_dv, dT_de);
    REL_TEST(T_ad.derivatives()[0], dT_dv, 0.0001);
    REL_TEST(T_ad.derivatives()[1], dT_de, 0.0001);
  }
 
  // AD e_from_p_rho
  {
    DNDerivativeType dpdx;
    DNDerivativeType drhodx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(drhodx, 0, 0);
    Moose::derivInsert(drhodx, 1, 1);
 
    Real rho = 1. / v;
    ADReal p_ad(p, dpdx);
    ADReal rho_ad(rho, drhodx);
    ADReal e_ad = _tab_ve_from_fp->e_from_p_rho(p_ad, rho_ad);
 
    Real e, de_dp, de_drho;
    _tab_ve_from_fp->e_from_p_rho(p, rho, e, de_dp, de_drho);
    REL_TEST(e_ad.derivatives()[0], de_dp, 0.0001);
    REL_TEST(e_ad.derivatives()[1], de_drho, 0.0001);
  }
 
  // AD T_from_p_rho
  {
    DNDerivativeType dpdx;
    DNDerivativeType drhodx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(drhodx, 0, 0);
    Moose::derivInsert(drhodx, 1, 1);
 
    Real rho = 1. / v;
    ADReal p_ad(p, dpdx);
    ADReal rho_ad(rho, drhodx);
    ADReal T_ad = _tab_ve_from_fp->T_from_p_rho(p_ad, rho_ad);
 
    Real T, dT_dp, dT_drho;
    _tab_ve_from_fp->T_from_p_rho(p, rho, T, dT_dp, dT_drho);
    REL_TEST(T_ad.derivatives()[0], dT_dp, 0.0001);
    REL_TEST(T_ad.derivatives()[1], dT_drho, 0.0001);
    // The AD and non-AD overloads must use the same (v, e) tabulation
    REL_TEST(T_ad.value(), _tab_ve_from_fp->T_from_p_rho(p, rho), REL_TOL_CONSISTENCY);
  }
 
  // AD e_from_p_T
  {
    DNDerivativeType dpdx;
    DNDerivativeType dTdx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(dTdx, 0, 0);
    Moose::derivInsert(dTdx, 1, 1);
 
    ADReal p_ad(p, dpdx);
    ADReal T_ad(T, dTdx);
    ADReal e_ad = _tab_ve_from_fp->e_from_p_T(p_ad, T_ad);
 
    Real e, de_dp, de_dT;
    _tab_ve_from_fp->e_from_p_T(p, T, e, de_dp, de_dT);
    REL_TEST(e_ad.derivatives()[0], de_dp, 0.0001);
    REL_TEST(e_ad.derivatives()[1], de_dT, 0.0001);
  }
 
  // AD rho_from_p_T
  {
    DNDerivativeType dpdx;
    DNDerivativeType dTdx;
    // set it up so these are the derivatives
    // w.r.t. to themselves
    Moose::derivInsert(dpdx, 0, 1);
    Moose::derivInsert(dpdx, 1, 0);
    Moose::derivInsert(dTdx, 0, 0);
    Moose::derivInsert(dTdx, 1, 1);
 
    Real p = _tab_ve_from_fp->p_from_v_e(v, e);
    Real T = _tab_ve_from_fp->p_from_v_e(v, e);
    ADReal p_ad(p, dpdx);
    ADReal T_ad(T, dTdx);
    ADReal rho_ad = _tab_ve_from_fp->rho_from_p_T(p_ad, T_ad);
 
    Real rho, drho_dp, drho_dT;
    _tab_ve_from_fp->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
    REL_TEST(rho_ad.derivatives()[0], drho_dp, 0.0001);
    REL_TEST(rho_ad.derivatives()[1], drho_dT, 0.0001);
  }
 
  // cannot test AD c_from_v_e because co2 props do not
  // implement enough
}
 
TEST_F(TabulatedBicubicFluidPropertiesTest, derivatives)
{
 
  const Real p = 1.5e6;
  const Real T = 452.0;
 
  {
    // Read the data file and generate (v,e) to (p,T) interpolations
    Moose::_throw_on_warning = false;
    const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_pT)->initialSetup();
    Moose::_throw_on_warning = true;
    const Real tol = REL_TOL_DERIVATIVE;
 
    const Real rho = _tab_ve_from_pT->rho_from_p_T(p, T);
    const Real v = 1. / rho;
    const Real e = _tab_ve_from_pT->e_from_p_T(p, T);
    const Real s = _tab_ve_from_pT->s_from_p_T(p, T);
 
    DERIV_TEST(_tab_ve_from_pT->rho_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->e_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->v_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->h_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->k_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->cp_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->cv_from_p_T, p, T, tol);
    DERIV_TEST(_tab_ve_from_pT->mu_from_p_T, p, T, tol);
 
    DERIV_TEST(_tab_ve_from_pT->p_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_pT->mu_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_pT->k_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_pT->T_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_pT->cp_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_pT->cv_from_v_e, v, e, tol);
 
    DERIV_TEST(_tab_ve_from_pT->T_from_p_rho, p, rho, tol);
    DERIV_TEST(_tab_ve_from_pT->e_from_p_rho, p, rho, tol);
 
    DERIV_TEST(_tab_ve_from_pT->T_from_p_s, p, s, tol);
    DERIV_TEST(_tab_ve_from_pT->rho_from_p_s, p, s, tol);
 
    // The temperature derivatives must not rely on relative perturbations of the arguments,
    // which vanish at zero entropy: (dT/ds)_p = T / cp. The CO2 entropy reference puts s = 0
    // within the range of the tabulation generated from CO2FluidProperties.
    {
      const Real s0 = 0.0;
      Real T0, dT_dp, dT_ds;
      _tab_pT_from_fp->T_from_p_s(p, s0, T0, dT_dp, dT_ds);
      REL_TEST(dT_ds, T0 / _tab_pT_from_fp->cp_from_p_T(p, T0), 1e-3);
    }
  }
 
  {
    // Read the data file with direct to (v,e) interpolations
    Moose::_throw_on_warning = false;
    const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_fp)->initialSetup();
    Moose::_throw_on_warning = true;
    const Real tol = REL_TOL_DERIVATIVE;
 
    const Real rho = _tab_ve_from_fp->rho_from_p_T(p, T);
    const Real v = 1. / rho;
    const Real e = _tab_ve_from_fp->e_from_p_T(p, T);
    const Real h = e + p * v;
 
    DERIV_TEST(_tab_ve_from_fp->p_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_fp->mu_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_fp->k_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_fp->T_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_fp->cp_from_v_e, v, e, tol);
    DERIV_TEST(_tab_ve_from_fp->cv_from_v_e, v, e, tol);
 
    // Jacobian warning and finite differencing in use
    Moose::_throw_on_warning = false;
    DERIV_TEST(_tab_ve_from_fp->e_from_v_h, v, h, 100 * tol);
    Moose::_throw_on_warning = true;
  }
}
 
// Test generation of tabulated fluid properties
TEST_F(TabulatedBicubicFluidPropertiesTest, generateTabulatedData)
{
  Real p = 1.5e6;
  Real T = 450.0;
 
  // Generate the tabulated data from the CO2 fluid properties
  const_cast<TabulatedBicubicFluidProperties *>(_tab_pT_from_fp_gen)->initialSetup();
 
  REL_TEST(_tab_pT_from_fp_gen->rho_from_p_T(p, T), _co2_fp->rho_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->h_from_p_T(p, T), _co2_fp->h_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->e_from_p_T(p, T), _co2_fp->e_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->mu_from_p_T(p, T), _co2_fp->mu_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->k_from_p_T(p, T), _co2_fp->k_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->cp_from_p_T(p, T), _co2_fp->cp_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->cv_from_p_T(p, T), _co2_fp->cv_from_p_T(p, T), 1.0e-4);
  REL_TEST(_tab_pT_from_fp_gen->s_from_p_T(p, T), _co2_fp->s_from_p_T(p, T), 1.0e-4);
}
 
// Test that all fluid properties are properly passed back to the given user object
// if they are not tabulated
TEST_F(TabulatedBicubicFluidPropertiesTest, passthrough)
{
  Real p = 1.5e6;
  Real T = 450.0;
  const Real tol = REL_TOL_SAVED_VALUE;
 
  // As the flags for interpolation in TabulatedBicubicFluidProperties default to false,
  // properties will be passed through to the given fluid properties object
  ABS_TEST(_tab_pT_from_fp->v_from_p_T(p, T), 1. / _co2_fp->rho_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->rho_from_p_T(p, T), _co2_fp->rho_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->h_from_p_T(p, T), _co2_fp->h_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->e_from_p_T(p, T), _co2_fp->e_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->mu_from_p_T(p, T), _co2_fp->mu_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->k_from_p_T(p, T), _co2_fp->k_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->cp_from_p_T(p, T), _co2_fp->cp_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->cv_from_p_T(p, T), _co2_fp->cv_from_p_T(p, T), tol);
  ABS_TEST(_tab_pT_from_fp->s_from_p_T(p, T), _co2_fp->s_from_p_T(p, T), tol);
 
  // These calls are always forwarded to the 'fp' parameter fluid properties because the
  // tabulations are not implemented
  ABS_TEST(_tab_pT_from_fp->henryCoefficients()[0], _co2_fp->henryCoefficients()[0], tol);
  ABS_TEST(_tab_pT_from_fp->henryCoefficients()[1], _co2_fp->henryCoefficients()[1], tol);
  ABS_TEST(_tab_pT_from_fp->henryCoefficients()[2], _co2_fp->henryCoefficients()[2], tol);
  ABS_TEST(_tab_pT_from_fp->triplePointPressure(), _co2_fp->triplePointPressure(), tol);
  ABS_TEST(_tab_pT_from_fp->triplePointTemperature(), _co2_fp->triplePointTemperature(), tol);
  ABS_TEST(_tab_pT_from_fp->criticalPressure(), _co2_fp->criticalPressure(), tol);
  ABS_TEST(_tab_pT_from_fp->criticalTemperature(), _co2_fp->criticalTemperature(), tol);
  ABS_TEST(_tab_pT_from_fp->criticalDensity(), _co2_fp->criticalDensity(), tol);
 
  // Use a temperature less than the critical point
  T = 300.0;
  ABS_TEST(_tab_pT_from_fp->vaporPressure(T), _co2_fp->vaporPressure(T), tol);
 
  // TODO: these properties are not implemented in CO2 fp so we cannot test the pass through
  // T_from_p_h
  // vaporPressure with saturation pressure
  // vaporTemperature
 
  // AD passthrough
  // Switching to IdealGas FP to have more definitions
  const_cast<TabulatedBicubicFluidProperties *>(_tab_pT_from_fp_idg)->initialSetup();
  DNDerivativeType dpdx;
  DNDerivativeType dTdx;
  Moose::derivInsert(dpdx, 0, 1);
  Moose::derivInsert(dpdx, 1, 0);
  Moose::derivInsert(dTdx, 0, 0);
  Moose::derivInsert(dTdx, 1, 1);
  ADReal p_ad(1.5e6, dpdx);
  ADReal T_ad(450.0, dTdx);
  // value
  ABS_TEST(_tab_pT_from_fp_idg->v_from_p_T(p_ad, T_ad).value(),
           _idg_fp->v_from_p_T(p_ad, T_ad).value(),
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->rho_from_p_T(p_ad, T_ad).value(),
           _idg_fp->rho_from_p_T(p_ad, T_ad).value(),
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->e_from_p_T(p_ad, T_ad).value(),
           _idg_fp->e_from_p_T(p_ad, T_ad).value(),
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->cp_from_p_T(p_ad, T_ad).value(),
           _idg_fp->cp_from_p_T(p_ad, T_ad).value(),
           tol);
  // derivatives
  ABS_TEST(_tab_pT_from_fp_idg->v_from_p_T(p_ad, T_ad).derivatives()[0],
           _idg_fp->v_from_p_T(p_ad, T_ad).derivatives()[0],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->rho_from_p_T(p_ad, T_ad).derivatives()[0],
           _idg_fp->rho_from_p_T(p_ad, T_ad).derivatives()[0],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->e_from_p_T(p_ad, T_ad).derivatives()[0],
           _idg_fp->e_from_p_T(p_ad, T_ad).derivatives()[0],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->cp_from_p_T(p_ad, T_ad).derivatives()[0],
           _idg_fp->cp_from_p_T(p_ad, T_ad).derivatives()[0],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->v_from_p_T(p_ad, T_ad).derivatives()[1],
           _idg_fp->v_from_p_T(p_ad, T_ad).derivatives()[1],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->rho_from_p_T(p_ad, T_ad).derivatives()[1],
           _idg_fp->rho_from_p_T(p_ad, T_ad).derivatives()[1],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->e_from_p_T(p_ad, T_ad).derivatives()[1],
           _idg_fp->e_from_p_T(p_ad, T_ad).derivatives()[1],
           tol);
  ABS_TEST(_tab_pT_from_fp_idg->cp_from_p_T(p_ad, T_ad).derivatives()[1],
           _idg_fp->cp_from_p_T(p_ad, T_ad).derivatives()[1],
           tol);
}
 
// Test that all fluid properties are properly passed back to the given user object
// if they are not tabulated
TEST_F(TabulatedBicubicFluidPropertiesTest, passthroughVE)
{
  Real p = 1.5e6;
  Real T = 450.0;
  Real v = 1. / _idg_fp->rho_from_p_T(p, T);
  Real e = _idg_fp->e_from_p_T(p, T);
  const Real tol = REL_TOL_CONSISTENCY;
 
  // need to generate (v,e) bounds
  const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_fp)->initialSetup();
  // we use this tabulation based on idg as too many (v,e) routines are missing for CO2
 
  // As the flags for interpolation in TabulatedBicubicFluidProperties default to false,
  // properties will be passed through to the given fluid properties object
  ABS_TEST(_tab_ve_from_fp->T_from_v_e(v, e), _idg_fp->T_from_v_e(v, e), tol);
  ABS_TEST(_tab_ve_from_fp->p_from_v_e(v, e), _idg_fp->p_from_v_e(v, e), 3 * tol);
  ABS_TEST(_tab_ve_from_fp->h_from_v_e(v, e), _idg_fp->h_from_v_e(v, e), tol);
  ABS_TEST(_tab_ve_from_fp->mu_from_v_e(v, e), _idg_fp->mu_from_v_e(v, e), tol);
  ABS_TEST(_tab_ve_from_fp->k_from_v_e(v, e), _idg_fp->k_from_v_e(v, e), tol);
  ABS_TEST(_tab_ve_from_fp->cp_from_v_e(v, e), _idg_fp->cp_from_v_e(v, e), tol);
  ABS_TEST(_tab_ve_from_fp->cv_from_v_e(v, e), _idg_fp->cv_from_v_e(v, e), tol);
  ABS_TEST(_tab_ve_from_fp->s_from_v_e(v, e), _idg_fp->s_from_v_e(v, e), 30 * tol);
 
  // passthrough with derivatives
  {
    Real pert = 1e-7;
    Real deriv1, deriv2;
    // temperature
    Real T1;
    _tab_ve_from_fp->T_from_v_e(v, e, T1, deriv1, deriv2);
    Real T_0 = _tab_ve_from_fp->T_from_v_e(v, e);
    Real T_1 = _tab_ve_from_fp->T_from_v_e(v * (1 + pert), e);
    Real T_2 = _tab_ve_from_fp->T_from_v_e(v, e * (1 + pert));
    REL_TEST(deriv1, (T_1 - T_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (T_2 - T_0) / (e * pert), 0.001);
 
    // pressure
    Real p1;
    _tab_ve_from_fp->p_from_v_e(v, e, p1, deriv1, deriv2);
    Real p_0 = _tab_ve_from_fp->p_from_v_e(v, e);
    Real p_1 = _tab_ve_from_fp->p_from_v_e(v * (1 + pert), e);
    Real p_2 = _tab_ve_from_fp->p_from_v_e(v, e * (1 + pert));
    REL_TEST(deriv1, (p_1 - p_0) / (v * pert), 0.001);
    REL_TEST(deriv2, (p_2 - p_0) / (e * pert), 0.001);
  }
}
 
TEST_F(TabulatedBicubicFluidPropertiesTest, fluidName)
{
  EXPECT_EQ(_tab_pT_from_fp->fluidName(), "co2");
}
 
TEST_F(TabulatedBicubicFluidPropertiesTest, molarMass)
{
  ABS_TEST(_tab_pT_from_fp->molarMass(), 44.0098e-3, REL_TOL_SAVED_VALUE);
}
 
TEST_F(TabulatedBicubicFluidPropertiesTest, combined)
{
  const Real p = 1.0e6;
  const Real T = 300.0;
  const Real tol = REL_TOL_CONSISTENCY;
 
  // Single property methods
  Real rho, drho_dp, drho_dT;
  _tab_pT_from_fp->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
  Real mu, dmu_dp, dmu_dT;
  _tab_pT_from_fp->mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
  Real e, de_dp, de_dT;
  _tab_pT_from_fp->e_from_p_T(p, T, e, de_dp, de_dT);
 
  // Combined property methods
  Real rho2, drho2_dp, drho2_dT, mu2, dmu2_dp, dmu2_dT, e2, de2_dp, de2_dT;
  _tab_pT_from_fp->rho_mu_from_p_T(p, T, rho2, mu2);
 
  ABS_TEST(rho, rho2, tol);
  ABS_TEST(mu, mu2, tol);
 
  _tab_pT_from_fp->rho_mu_from_p_T(p, T, rho2, drho2_dp, drho2_dT, mu2, dmu2_dp, dmu2_dT);
  ABS_TEST(rho, rho2, tol);
  ABS_TEST(drho_dp, drho2_dp, tol);
  ABS_TEST(drho_dT, drho2_dT, tol);
  ABS_TEST(mu, mu2, tol);
  ABS_TEST(dmu_dp, dmu2_dp, tol);
  ABS_TEST(dmu_dT, dmu2_dT, tol);
 
  _tab_pT_from_fp->rho_e_from_p_T(p, T, rho2, drho2_dp, drho2_dT, e2, de2_dp, de2_dT);
  ABS_TEST(rho, rho2, tol);
  ABS_TEST(drho_dp, drho2_dp, tol);
  ABS_TEST(drho_dT, drho2_dT, tol);
  ABS_TEST(e, e2, tol);
  ABS_TEST(de_dp, de2_dp, tol);
  ABS_TEST(de_dT, de2_dT, tol);
}
 
TEST_F(TabulatedBicubicFluidPropertiesTest, gibbsWithoutTemperatureColumn)
{
  InputParameters params = _factory.getValidParams("TabulatedBicubicFluidProperties");
  params.set<UserObjectName>("input_fp") = "idg_fp";
  params.set<MooseEnum>("out_of_bounds_behavior") = "set_to_closest_bound";
  params.set<bool>("create_pT_interpolations") = false;
  params.set<bool>("create_ve_interpolations") = true;
  params.set<bool>("construct_pT_from_ve") = true;
  params.set<Real>("temperature_min") = 400;
  params.set<Real>("temperature_max") = 500;
  params.set<Real>("pressure_min") = 1e6;
  params.set<Real>("pressure_max") = 2e6;
  params.set<Real>("T_initial_guess") = 450;
  params.set<Real>("p_initial_guess") = 1.5e6;
  MultiMooseEnum properties("density enthalpy viscosity k c cv cp entropy pressure temperature",
                            "density enthalpy entropy");
  params.set<MultiMooseEnum>("interpolated_properties") = properties;
  _fe_problem->addUserObject("TabulatedBicubicFluidProperties", "tab_ve_no_T", params);
  auto & fp = _fe_problem->getUserObject<TabulatedBicubicFluidProperties>("tab_ve_no_T");
  Moose::_throw_on_warning = false;
  fp.initialSetup();
  Moose::_throw_on_warning = true;
 
  const Real p = 1.5e6;
  const Real T = 450.0;
  const Real v = _idg_fp->v_from_p_T(p, T);
  const Real e = _idg_fp->e_from_p_T(p, T);
  REL_TEST(fp.g_from_v_e(v, e), _idg_fp->g_from_v_e(v, e), 1e-3);
}
 
TEST_F(TabulatedBicubicFluidPropertiesTest, checkNaNsMidpoint)
{
  InputParameters params = _factory.getValidParams("CheckNaNsTabulatedFluidProperties");
  params.set<UserObjectName>("input_fp") = "idg_fp";
  _fe_problem->addUserObject("CheckNaNsTabulatedFluidProperties", "check_nans_fp", params);
  auto & fp = _fe_problem->getUserObject<CheckNaNsTabulatedFluidProperties>("check_nans_fp");
  fp.setSpecificVolumeGrid({1.0, 2.0, 3.0});
 
  for (const auto i : make_range(3u))
  {
    Real p = std::numeric_limits<Real>::quiet_NaN();
    Real T = std::numeric_limits<Real>::quiet_NaN();
    unsigned int num_nans_p = 0, num_nans_T = 0;
    fp.checkNaNs(1e5, 1e6, 300, 500, i, p, T, num_nans_p, num_nans_T);
    EXPECT_FALSE(std::isnan(p));
    EXPECT_FALSE(std::isnan(T));
    EXPECT_EQ(num_nans_p, 1u);
    EXPECT_EQ(num_nans_T, 1u);
  }
}