CaloricallyImperfectGasTest.C File Reference

Go to the source code of this file.

Functions
	TEST_F (CaloricallyImperfectGasTest, testAll)
	Verify that the fluid name is correctly returned.
	TEST_F (CaloricallyImperfectGasTest, nonMonotonicError1)
	TEST_F (CaloricallyImperfectGasTest, nonMonotonicError2)
	TEST_F (CaloricallyImperfectGasTest, compareWithIdeal)
	TEST_F (CaloricallyImperfectGasTest, soundSpeedVaryingGamma)
	Verify the sound speed derivatives for an internal energy that is quadratic in temperature, so that the specific heat ratio varies with the internal energy.
	TEST_F (CaloricallyImperfectGasTest, lookupTableBounds)
	Verify the lookup tables at and beyond their bounds.
	TEST_F (CaloricallyImperfectGasTest, derivativesAtEdgeStates)
	Verify derivatives that were computed with relative finite-difference steps, at states where the step would vanish (s = 0) or leave the table (T = max_temperature)

Function Documentation

TEST_F() [1/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		compareWithIdeal
	)

Definition at line 548 of file CaloricallyImperfectGasTest.C.

{
  const IdealGasFluidProperties * ideal;
  const CaloricallyImperfectGas * compare_with_ideal;
  // compare ideal gas and calorically imperfect gas
  InputParameters ideal_uo_pars = _factory.getValidParams("IdealGasFluidProperties");
  ideal_uo_pars.set<Real>("molar_mass") = 0.002;
  ideal_uo_pars.set<Real>("gamma") = 1.41;
  _fe_problem->addUserObject("IdealGasFluidProperties", "ideal_fp", ideal_uo_pars);
  ideal = &_fe_problem->getUserObject<IdealGasFluidProperties>("ideal_fp");
 
  Real Ru = 8.31446261815324;
  Real Rs = Ru / 0.002;
  Real gamma = 1.41;
  Real cp_val = gamma / (gamma - 1) * Rs;
  Real cv_val = cp_val / gamma;
  std::vector<Real> temps = {0.0, 500.0};
  std::vector<Real> internal_energies = {0.0, 500.0 * cv_val};
 
  InputParameters lin_e_fn_params = _factory.getValidParams("PiecewiseLinear");
  lin_e_fn_params.set<std::vector<Real>>("x") = temps;
  lin_e_fn_params.set<std::vector<Real>>("y") = internal_energies;
  _fe_problem->addFunction("PiecewiseLinear", "lin_e_fn", lin_e_fn_params);
 
  InputParameters compare_uo_pars = _factory.getValidParams("CaloricallyImperfectGas");
  compare_uo_pars.set<Real>("molar_mass") = 0.002;
  compare_uo_pars.set<FunctionName>("e") = "lin_e_fn";
  compare_uo_pars.set<FunctionName>("mu") = "default_fn";
  compare_uo_pars.set<FunctionName>("k") = "default_fn";
  compare_uo_pars.set<Real>("min_temperature") = 100.0;
  compare_uo_pars.set<Real>("max_temperature") = 500.0;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "compare_fp", compare_uo_pars);
  compare_with_ideal = &_fe_problem->getUserObject<CaloricallyImperfectGas>("compare_fp");
 
  const_cast<CaloricallyImperfectGas *>(compare_with_ideal)->initialSetup();
 
  Real T = 325.0;
  Real p = 1.0e6;
 
  // test all functions that provide x_from_p_T, x_from_v_e, e_from_v_h, e_from_p_rho
  {
    Real v = ideal->v_from_p_T(p, T);
    Real e = ideal->e_from_p_T(p, T);
    Real rho = ideal->rho_from_p_T(p, T);
    Real h = ideal->h_from_p_T(p, T);
    REL_TEST(ideal->c_from_p_T(p, T), compare_with_ideal->c_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->rho_from_p_T(p, T), compare_with_ideal->rho_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->h_from_p_T(p, T), compare_with_ideal->h_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->e_from_p_T(p, T), compare_with_ideal->e_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->cv_from_p_T(p, T), compare_with_ideal->cv_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->cp_from_p_T(p, T), compare_with_ideal->cp_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->T_from_v_e(v, e), compare_with_ideal->T_from_v_e(v, e), 1e-5);
    REL_TEST(ideal->c_from_v_e(v, e), compare_with_ideal->c_from_v_e(v, e), 1e-5);
    REL_TEST(ideal->cv_from_v_e(v, e), compare_with_ideal->cv_from_v_e(v, e), 1e-5);
    REL_TEST(ideal->cp_from_v_e(v, e), compare_with_ideal->cp_from_v_e(v, e), 1e-5);
    REL_TEST(ideal->e_from_v_h(v, h), compare_with_ideal->e_from_v_h(v, h), 1e-5);
    REL_TEST(ideal->e_from_p_rho(p, rho), compare_with_ideal->e_from_p_rho(p, rho), 1e-5);
    REL_TEST(ideal->e_from_T_v(T, v), compare_with_ideal->e_from_T_v(T, v), 1e-5);
    REL_TEST(ideal->p_from_T_v(T, v), compare_with_ideal->p_from_T_v(T, v), 1e-5);
    REL_TEST(ideal->gamma_from_p_T(p, T), compare_with_ideal->gamma_from_p_T(p, T), 1e-5);
    REL_TEST(ideal->gamma_from_v_e(v, e), compare_with_ideal->gamma_from_v_e(v, e), 1e-5);
  }
 
  // test derivatives for c_from_v_e
  {
    Real v = ideal->v_from_p_T(p, T);
    Real e = ideal->e_from_p_T(p, T);
    Real c = 0, dc_dv = 0, dc_de = 0;
    ideal->c_from_v_e(v, e, c, dc_dv, dc_de);
    Real c2 = 0, dc_dv2 = 0, dc_de2 = 0;
    compare_with_ideal->c_from_v_e(v, e, c2, dc_dv2, dc_de2);
    REL_TEST(dc_dv, dc_dv2, 1e-5);
    REL_TEST(dc_de, dc_de2, 1e-5);
  }
 
  // test derivatives for p_from_v_e
  {
    Real v = ideal->v_from_p_T(p, T);
    Real e = ideal->e_from_p_T(p, T);
    Real pp = 0, dp_dv = 0, dp_de = 0;
    ideal->p_from_v_e(v, e, pp, dp_dv, dp_de);
    Real pp2 = 0, dp_dv2 = 0, dp_de2 = 0;
    compare_with_ideal->p_from_v_e(v, e, pp2, dp_dv2, dp_de2);
    REL_TEST(dp_dv, dp_dv2, 1e-5);
    REL_TEST(dp_de, dp_de2, 1e-5);
  }
 
  // test derivatives for T_from_v_e
  {
    Real v = ideal->v_from_p_T(p, T);
    Real e = ideal->e_from_p_T(p, T);
    Real TT = 0, dT_dv = 0, dT_de = 0;
    ideal->T_from_v_e(v, e, TT, dT_dv, dT_de);
    Real TT2 = 0, dT_dv2 = 0, dT_de2 = 0;
    compare_with_ideal->T_from_v_e(v, e, TT2, dT_dv2, dT_de2);
    REL_TEST(dT_dv, dT_dv2, 1e-5);
    REL_TEST(dT_de, dT_de2, 1e-5);
  }
 
  // test derivatives for e_from_v_h
  {
    Real v = ideal->v_from_p_T(p, T);
    Real h = ideal->h_from_p_T(p, T);
    Real ee = 0, de_dv = 0, de_dh = 0;
    ideal->e_from_v_h(v, h, ee, de_dv, de_dh);
    Real ee2 = 0, de_dv2 = 0, de_dh2 = 0;
    compare_with_ideal->e_from_v_h(v, h, ee2, de_dv2, de_dh2);
    REL_TEST(de_dv, de_dv2, 1e-5);
    REL_TEST(de_dh, de_dh2, 1e-5);
  }
}

TEST_F() [2/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		derivativesAtEdgeStates
	)

Verify derivatives that were computed with relative finite-difference steps, at states where the step would vanish (s = 0) or leave the table (T = max_temperature)

Definition at line 741 of file CaloricallyImperfectGasTest.C.

{
  InputParameters e_fn_params = _factory.getValidParams("ParsedFunction");
  e_fn_params.set<std::string>("expression") = "3000 * t + 2 * t * t";
  _fe_problem->addFunction("ParsedFunction", "e_edge_fn", e_fn_params);
  _fe_problem->getFunction("e_edge_fn").initialSetup();
 
  InputParameters uo_pars = _factory.getValidParams("CaloricallyImperfectGas");
  uo_pars.set<Real>("molar_mass") = 0.002;
  uo_pars.set<FunctionName>("e") = "e_edge_fn";
  uo_pars.set<FunctionName>("mu") = "e_edge_fn";
  uo_pars.set<FunctionName>("k") = "e_edge_fn";
  uo_pars.set<Real>("min_temperature") = 100.0;
  uo_pars.set<Real>("max_temperature") = 500.0;
  uo_pars.set<Real>("temperature_resolution") = 0.01;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "fp_edge", uo_pars);
  auto & fp = _fe_problem->getUserObject<CaloricallyImperfectGas>("fp_edge");
  fp.initialSetup();
 
  // (dp/dh)_s = rho and (dp/ds)_h = -T rho, from dh = T ds + v dp
  const Real T = 300.0;
  const Real v = 1.0 / fp.rho_from_p_T(1e5, T);
  const Real h = fp.h_from_T_v(T, v);
  // The entropy reference makes s = 0 at the state with Z(T) + R ln(v) = 0
  const Real s0 = 0.0;
  Real p, dp_dh, dp_ds;
  fp.p_from_h_s(h, s0, p, dp_dh, dp_ds);
  const Real T0 = fp.T_from_p_h(p, h);
  const Real rho0 = fp.rho_from_p_T(p, T0);
  REL_TEST(dp_dh, rho0, REL_TOL_DERIVATIVE);
  REL_TEST(dp_ds, -T0 * rho0, REL_TOL_DERIVATIVE);
 
  // Temperature derivatives at the upper bound of the table must not leave the table
  Real cp, dcp_dp, dcp_dT;
  fp.cp_from_p_T(1e5, 500.0, cp, dcp_dp, dcp_dT);
  REL_TEST(dcp_dT, 4.0, 1e-4);
  Real mu, dmu_dp, dmu_dT;
  fp.mu_from_p_T(1e5, 500.0, mu, dmu_dp, dmu_dT);
  REL_TEST(dmu_dT, 3000.0 + 4.0 * 500.0, 1e-4);
}

TEST_F() [3/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		lookupTableBounds
	)

Verify the lookup tables at and beyond their bounds.

Definition at line 697 of file CaloricallyImperfectGasTest.C.

{
  const bool original_throw_on_warning = Moose::_throw_on_warning;
  Moose::_throw_on_warning = false;
 
  InputParameters e_fn_params = _factory.getValidParams("PiecewiseLinear");
  e_fn_params.set<std::vector<Real>>("x") = {100, 500};
  e_fn_params.set<std::vector<Real>>("y") = {1e6, 5e6};
  _fe_problem->addFunction("PiecewiseLinear", "e_lin_fn", e_fn_params);
 
  InputParameters uo_pars = _factory.getValidParams("CaloricallyImperfectGas");
  uo_pars.set<Real>("molar_mass") = 0.002;
  uo_pars.set<FunctionName>("e") = "e_lin_fn";
  uo_pars.set<FunctionName>("mu") = "default_fn";
  uo_pars.set<FunctionName>("k") = "default_fn";
  uo_pars.set<Real>("min_temperature") = 100.0;
  uo_pars.set<Real>("max_temperature") = 500.0;
  uo_pars.set<Real>("temperature_resolution") = 1.0;
  uo_pars.set<bool>("out_of_bound_error") = false;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "fp_bounds", uo_pars);
  auto & fp = _fe_problem->getUserObject<CaloricallyImperfectGas>("fp_bounds");
  fp.initialSetup();
 
  const Real v = 1.0;
  const Real p = 1e5;
  // Upper bound of the T(e), T(h) and Z(T) tables
  REL_TEST(fp.T_from_v_e(v, 5e6), 500.0, REL_TOL_CONSISTENCY);
  REL_TEST(fp.T_from_p_h(p, fp.h_from_p_T(p, 500.0)), 500.0, REL_TOL_CONSISTENCY);
  EXPECT_TRUE(std::isfinite(fp.s_from_p_T(p, 500.0)));
  // Below and above the tables, the values are clamped to the bounds
  REL_TEST(fp.T_from_v_e(v, 0.5e6), 100.0, REL_TOL_CONSISTENCY);
  REL_TEST(fp.T_from_v_e(v, 6e6), 500.0, REL_TOL_CONSISTENCY);
  // s(T, v) = Z(T) + R ln(v), so at fixed v the entropy outside the table equals that at
  // the nearest bound
  REL_TEST(fp.s_from_T_v(50.0, v), fp.s_from_T_v(100.0, v), REL_TOL_CONSISTENCY);
  REL_TEST(fp.s_from_T_v(600.0, v), fp.s_from_T_v(500.0, v), REL_TOL_CONSISTENCY);
 
  Moose::_throw_on_warning = original_throw_on_warning;
}

TEST_F() [4/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		nonMonotonicError1
	)

Definition at line 482 of file CaloricallyImperfectGasTest.C.

{
  // Testing case where e(T) is not monotonic
  const CaloricallyImperfectGas * fp_bad_e_fn;
  std::vector<Real> T = {100, 200, 300, 400, 500};
  std::vector<Real> bad_e = {2859400, 8578200, 17156400, 8578200, 42891000};
  InputParameters bad_e_fn_params = _factory.getValidParams("PiecewiseLinear");
  bad_e_fn_params.set<std::vector<Real>>("x") = T;
  bad_e_fn_params.set<std::vector<Real>>("y") = bad_e;
  _fe_problem->addFunction("PiecewiseLinear", "bad_e_fn", bad_e_fn_params);
 
  InputParameters uo_pars_bad_e_fn = _factory.getValidParams("CaloricallyImperfectGas");
  uo_pars_bad_e_fn.set<Real>("molar_mass") = 0.002;
  uo_pars_bad_e_fn.set<FunctionName>("e") = "bad_e_fn";
  uo_pars_bad_e_fn.set<FunctionName>("mu") = "default_fn";
  uo_pars_bad_e_fn.set<FunctionName>("k") = "default_fn";
  uo_pars_bad_e_fn.set<Real>("min_temperature") = 100.0;
  uo_pars_bad_e_fn.set<Real>("max_temperature") = 500.0;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "fp_bad_e_fn", uo_pars_bad_e_fn);
  fp_bad_e_fn = &_fe_problem->getUserObject<CaloricallyImperfectGas>("fp_bad_e_fn");
 
  try
  {
    const_cast<CaloricallyImperfectGas *>(fp_bad_e_fn)->initialSetup();
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what()).find("e(T) is not monotonically increasing with T");
    ASSERT_TRUE(pos != std::string::npos);
  }
}

TEST_F() [5/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		nonMonotonicError2
	)

Definition at line 515 of file CaloricallyImperfectGasTest.C.

{
  // test for bad temperature values that violate min/max temperature
  const CaloricallyImperfectGas * fp_bad_e_fn2;
  std::vector<Real> e = {1825110, 5272540, 10342290, 17034360, 25348750};
  std::vector<Real> bad_T = {150, 200, 300, 400, 500};
  InputParameters bad_e_fn_params2 = _factory.getValidParams("PiecewiseLinear");
  bad_e_fn_params2.set<std::vector<Real>>("x") = bad_T;
  bad_e_fn_params2.set<std::vector<Real>>("y") = e;
  _fe_problem->addFunction("PiecewiseLinear", "bad_e_fn2", bad_e_fn_params2);
 
  InputParameters uo_pars_bad_e_fn2 = _factory.getValidParams("CaloricallyImperfectGas");
  uo_pars_bad_e_fn2.set<Real>("molar_mass") = 0.002;
  uo_pars_bad_e_fn2.set<FunctionName>("e") = "bad_e_fn2";
  uo_pars_bad_e_fn2.set<FunctionName>("mu") = "default_fn";
  uo_pars_bad_e_fn2.set<FunctionName>("k") = "default_fn";
  uo_pars_bad_e_fn2.set<Real>("min_temperature") = 100.0;
  uo_pars_bad_e_fn2.set<Real>("max_temperature") = 500.0;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "fp_bad_e_fn2", uo_pars_bad_e_fn2);
  fp_bad_e_fn2 = &_fe_problem->getUserObject<CaloricallyImperfectGas>("fp_bad_e_fn2");
 
  try
  {
    const_cast<CaloricallyImperfectGas *>(fp_bad_e_fn2)->initialSetup();
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what()).find("e(T) is not monotonically increasing with T");
    ASSERT_TRUE(pos != std::string::npos);
  }
}

TEST_F() [6/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		soundSpeedVaryingGamma
	)

Verify the sound speed derivatives for an internal energy that is quadratic in temperature, so that the specific heat ratio varies with the internal energy.

Definition at line 664 of file CaloricallyImperfectGasTest.C.

{
  // e(T) = 3000 T + 2 T^2, so cv = 3000 + 4 T and the specific heat ratio vary continuously
  InputParameters e_fn_params = _factory.getValidParams("ParsedFunction");
  e_fn_params.set<std::string>("expression") = "3000 * t + 2 * t * t";
  _fe_problem->addFunction("ParsedFunction", "e_quad_fn", e_fn_params);
  _fe_problem->getFunction("e_quad_fn").initialSetup();
 
  InputParameters uo_pars = _factory.getValidParams("CaloricallyImperfectGas");
  uo_pars.set<Real>("molar_mass") = 0.002;
  uo_pars.set<FunctionName>("e") = "e_quad_fn";
  uo_pars.set<FunctionName>("mu") = "default_fn";
  uo_pars.set<FunctionName>("k") = "default_fn";
  uo_pars.set<Real>("min_temperature") = 100.0;
  uo_pars.set<Real>("max_temperature") = 500.0;
  uo_pars.set<Real>("temperature_resolution") = 0.01;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "fp_quad", uo_pars);
  auto & fp = _fe_problem->getUserObject<CaloricallyImperfectGas>("fp_quad");
  fp.initialSetup();
 
  const Real T = 300.0;
  const Real p = 1e5;
  const Real v = 1.0 / fp.rho_from_p_T(p, T);
  const Real e = fp.e_from_p_T(p, T);
 
  // The tolerance accounts for the linear interpolation of the T(e) lookup table
  DERIV_TEST_CUSTOM_PERTURBATION(fp.c_from_v_e, v, e, 1e-4, 1e-4);
  DERIV_TEST_CUSTOM_PERTURBATION(fp.gamma_from_v_e, v, e, 1e-4, 1e-4);
}

TEST_F() [7/7]

TEST_F	(	CaloricallyImperfectGasTest	,
		testAll
	)

Verify that the fluid name is correctly returned.

Definition at line 16 of file CaloricallyImperfectGasTest.C.

{
  const CaloricallyImperfectGas * fp;
  std::vector<Real> T = {100, 200, 300, 400, 500};
  std::vector<Real> e = {1825110, 5272540, 10342290, 17034360, 25348750};
  std::vector<Real> T2 = {100, 500};
  std::vector<Real> mu = {1, 6};
  std::vector<Real> k = {11, 1};
 
  InputParameters e_fn_params = _factory.getValidParams("PiecewiseLinear");
  e_fn_params.set<std::vector<Real>>("x") = T;
  e_fn_params.set<std::vector<Real>>("y") = e;
  _fe_problem->addFunction("PiecewiseLinear", "e_fn", e_fn_params);
 
  InputParameters mu_fn_params = _factory.getValidParams("PiecewiseLinear");
  mu_fn_params.set<std::vector<Real>>("x") = T2;
  mu_fn_params.set<std::vector<Real>>("y") = mu;
  _fe_problem->addFunction("PiecewiseLinear", "mu_fn", mu_fn_params);
 
  InputParameters k_fn_params = _factory.getValidParams("PiecewiseLinear");
  k_fn_params.set<std::vector<Real>>("x") = T2;
  k_fn_params.set<std::vector<Real>>("y") = k;
  _fe_problem->addFunction("PiecewiseLinear", "k_fn", k_fn_params);
 
  InputParameters uo_pars = _factory.getValidParams("CaloricallyImperfectGas");
  uo_pars.set<Real>("molar_mass") = 0.002;
  uo_pars.set<FunctionName>("e") = "e_fn";
  uo_pars.set<FunctionName>("mu") = "mu_fn";
  uo_pars.set<FunctionName>("k") = "k_fn";
  uo_pars.set<Real>("min_temperature") = 100.0;
  uo_pars.set<Real>("max_temperature") = 500.0;
  uo_pars.set<Real>("temperature_resolution") = 0.01;
  _fe_problem->addUserObject("CaloricallyImperfectGas", "fp", uo_pars);
  fp = &_fe_problem->getUserObject<CaloricallyImperfectGas>("fp");
 
  const_cast<CaloricallyImperfectGas *>(fp)->initialSetup();
 
  Real min_T = 100.0;
  Real max_T = 500.0;
  unsigned int np = 200;
  Real dT = (max_T - min_T) / ((Real)np - 1.0);
  Real Ru = 8.31446261815324;
  Real Rs = Ru / 0.002;
 
  // Consistency checks
  {
    for (unsigned int j = 1; j < np - 1; ++j)
    {
      Real T = min_T + j * dT;
      Real p = 1.0e6;
      const Real rho = fp->rho_from_p_T(p, T);
      const Real v = 1.0 / rho;
      Real h = fp->h_from_p_T(p, T);
      Real e = fp->e_from_p_T(p, T);
      Real cp = fp->cp_from_p_T(p, T);
      Real cv = fp->cv_from_p_T(p, T);
      Real k = fp->k_from_p_T(p, T);
      Real mu = fp->mu_from_p_T(p, T);
      Real s = fp->s_from_p_T(p, T);
 
      // test rho_from_p_s
      REL_TEST(fp->rho_from_p_s(p, s), rho, 10.0 * REL_TOL_CONSISTENCY);
 
      // test e_from_x_y functions
      REL_TEST(fp->e_from_v_h(v, h), e, 10.0 * REL_TOL_CONSISTENCY);
      REL_TEST(fp->e_from_p_rho(p, rho), e, 10.0 * REL_TOL_CONSISTENCY);
      REL_TEST(fp->e_from_T_v(T, v), e, 10.0 * REL_TOL_CONSISTENCY);
 
      // test cv_x_y  functions
      REL_TEST(fp->cv_from_T_v(T, v), cv, 10.0 * REL_TOL_CONSISTENCY);
      REL_TEST(fp->cv_from_v_e(v, e), cv, 10.0 * REL_TOL_CONSISTENCY);
 
      // test cp_x_y  functions
      REL_TEST(fp->cp_from_v_e(v, e), cp, 10.0 * REL_TOL_CONSISTENCY);
 
      // test h_from_x_y functions
      REL_TEST(fp->h_from_T_v(T, v), h, 10.0 * REL_TOL_CONSISTENCY);
 
      // test p_from_x_y functions
      REL_TEST(fp->p_from_v_e(v, e), p, 10.0 * REL_TOL_CONSISTENCY);
      REL_TEST(fp->p_from_T_v(T, v), p, 10.0 * REL_TOL_CONSISTENCY);
 
      // test T_from_x_y functions
      REL_TEST(fp->T_from_p_h(p, h), T, 10.0 * REL_TOL_CONSISTENCY);
      REL_TEST(fp->T_from_v_e(v, e), T, 10.0 * REL_TOL_CONSISTENCY);
 
      // test k_from_x_y functions
      REL_TEST(fp->k_from_v_e(v, e), k, 10.0 * REL_TOL_CONSISTENCY);
 
      // test mu_from_x_y functions
      REL_TEST(fp->mu_from_v_e(v, e), mu, 10.0 * REL_TOL_CONSISTENCY);
    }
  }
 
  // AD consistency checks
  {
    for (unsigned int j = 1; j < np - 1; ++j)
    {
      Real T = min_T + j * dT;
      Real p = 1.0e6;
      const Real rho = fp->rho_from_p_T(p, T);
      const Real v = 1.0 / rho;
      Real e = fp->e_from_p_T(p, T);
      Real cv = fp->cv_from_p_T(p, T);
      Real c = fp->c_from_p_T(p, T);
 
      ADReal ad_e = e;
      ADReal ad_v = v;
      ADReal ad_p = fp->p_from_v_e(ad_v, ad_e);
      Real tol = 1e-11;
      REL_TEST(MetaPhysicL::raw_value(ad_p), p, tol);
 
      ADReal ad_T = fp->T_from_v_e(ad_v, ad_e);
      REL_TEST(MetaPhysicL::raw_value(ad_T), T, tol);
 
      REL_TEST(MetaPhysicL::raw_value(fp->cv_from_v_e(ad_v, ad_e)), cv, tol);
 
      ADReal ad_rho = fp->rho_from_p_T(ad_p, ad_T);
      REL_TEST(MetaPhysicL::raw_value(ad_rho), rho, tol);
 
      REL_TEST(MetaPhysicL::raw_value(fp->e_from_p_rho(ad_p, ad_rho)), e, tol);
      REL_TEST(MetaPhysicL::raw_value(fp->e_from_T_v(ad_T, ad_v)), e, tol);
      REL_TEST(MetaPhysicL::raw_value(fp->e_from_p_T(ad_p, ad_T)), e, tol);
      REL_TEST(
          MetaPhysicL::raw_value(fp->gamma_from_v_e(ad_v, ad_e)), fp->gamma_from_v_e(v, e), tol);
      REL_TEST(MetaPhysicL::raw_value(fp->gamma_from_p_T(ad_p, ad_T)),
               fp->gamma_from_p_T(ad_p, ad_T),
               tol);
      REL_TEST(MetaPhysicL::raw_value(fp->c_from_v_e(ad_v, ad_e)), c, tol);
      REL_TEST(MetaPhysicL::raw_value(fp->c_from_p_T(ad_p, ad_T)), c, tol);
    }
  }
 
  // check e/h lookups for T = 325.0 & e_from_v_h
  {
    Real T = 325.0;
    Real p = 1.0e6;
    Real e = 10342290 * 0.75 + 17034360 * 0.25;
    Real h = e + p / fp->rho_from_p_T(p, T);
    Real v = fp->v_from_p_T(p, T);
 
    REL_TEST(h, fp->h_from_p_T(p, T), 1e-5);
    REL_TEST(e, fp->e_from_p_T(p, T), 1e-5);
    REL_TEST(e, fp->e_from_v_h(v, h), 1e-5);
  }
 
  // check cv/cp lookups for T = 325.0
  {
    Real T = 325.0;
    Real p = 1.0e6;
    Real cv = (17034360.0 - 10342290.0) / 100.0;
    Real cp = cv + 8.3144598 / 0.002;
    REL_TEST(cp, fp->cp_from_p_T(p, T), 1e-5);
    REL_TEST(cv, fp->cv_from_p_T(p, T), 1e-5);
 
    Real v = fp->v_from_p_T(p, T);
    Real e = fp->e_from_p_T(p, T);
    REL_TEST(cp, fp->cp_from_v_e(v, e), 1e-5);
    REL_TEST(cv, fp->cv_from_v_e(v, e), 1e-5);
  }
 
  // test mu(p, T), mu(v, e), k(p, T), k(v, e) & derivatives
  {
    Real T = 250.0;
    Real p = 1.0e6;
    REL_TEST(fp->mu_from_p_T(p, T), 2.875, 1e-5);
    REL_TEST(fp->k_from_p_T(p, T), 7.25, 1e-5);
 
    Real v = fp->v_from_p_T(p, T);
    Real e = fp->e_from_p_T(p, T);
    REL_TEST(fp->mu_from_v_e(v, e), 2.875, 0.001);
    REL_TEST(fp->k_from_v_e(v, e), 7.25, 0.001);
 
    Real mu, dmu_dp, dmu_dT;
    fp->mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
    REL_TEST(dmu_dT, 0.0125, 1e-5);
 
    Real k, dk_dp, dk_dT;
    fp->k_from_p_T(p, T, k, dk_dp, dk_dT);
    REL_TEST(dk_dT, -0.025, 1e-5);
 
    Real cv = fp->cv_from_p_T(p, T);
    Real dmu_dv, dmu_de;
    fp->mu_from_v_e(v, e, mu, dmu_dv, dmu_de);
    REL_TEST(dmu_de, 0.0125 / cv, 0.001);
 
    Real dk_dv, dk_de;
    fp->k_from_v_e(v, e, k, dk_dv, dk_de);
    REL_TEST(dk_de, -0.025 / cv, 0.001);
  }
 
  // 5 argument functions
  {
    Real T = 325.0;
    Real p = 1.0e6;
    Real e = 10342290 * 0.75 + 17034360 * 0.25;
    Real h = e + p / fp->rho_from_p_T(p, T);
    Real v = fp->v_from_p_T(p, T);
    Real rho = 1.0 / v;
    Real cp = fp->cp_from_p_T(p, T);
    Real cv = fp->cv_from_p_T(p, T);
    Real s = fp->s_from_p_T(p, T);
    Real mu = fp->mu_from_v_e(v, e);
    Real k = fp->k_from_v_e(v, e);
    Real gamma = fp->gamma_from_p_T(p, T);
    Real ssound = fp->c_from_p_T(p, T);
    Real tol = 1e-12;
 
    {
      Real a, b, c;
      fp->p_from_v_e(v, e, a, b, c);
      REL_TEST(a, p, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->p_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->T_from_v_e(v, e, a, b, c);
      REL_TEST(a, T, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->T_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->cp_from_v_e(v, e, a, b, c);
      REL_TEST(a, cp, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->cp_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->cv_from_v_e(v, e, a, b, c);
      REL_TEST(a, cv, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->cv_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->mu_from_v_e(v, e, a, b, c);
      REL_TEST(a, mu, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->mu_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->k_from_v_e(v, e, a, b, c);
      REL_TEST(a, k, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->k_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->s_from_v_e(v, e, a, b, c);
      REL_TEST(a, s, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->s_from_p_T(p, T, a, b, c);
      REL_TEST(a, s, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->s_from_h_p(h, p, a, b, c);
      REL_TEST(a, s, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_h_p, h, p, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->e_from_v_h(v, h, a, b, c);
      REL_TEST(a, e, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->e_from_v_h, v, h, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->rho_from_p_T(p, T, a, b, c);
      REL_TEST(a, rho, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->rho_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->e_from_p_rho(p, rho, a, b, c);
      REL_TEST(a, e, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->e_from_p_rho, p, rho, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->e_from_T_v(T, v, a, b, c);
      REL_TEST(a, e, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->e_from_T_v, T, v, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->p_from_T_v(T, v, a, b, c);
      REL_TEST(a, p, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->p_from_T_v, T, v, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->h_from_T_v(T, v, a, b, c);
      REL_TEST(a, h, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->h_from_T_v, T, v, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->s_from_T_v(T, v, a, b, c);
      REL_TEST(a, s, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_T_v, T, v, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->h_from_p_T(p, T, a, b, c);
      REL_TEST(a, h, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->h_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->e_from_p_T(p, T, a, b, c);
      REL_TEST(a, e, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->e_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->T_from_p_h(p, h, a, b, c);
      REL_TEST(a, T, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->T_from_p_h, p, h, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->cv_from_p_T(p, T, a, b, c);
      REL_TEST(a, cv, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->cv_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->cp_from_p_T(p, T, a, b, c);
      REL_TEST(a, cp, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->cp_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->mu_from_p_T(p, T, a, b, c);
      REL_TEST(a, mu, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->mu_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->k_from_p_T(p, T, a, b, c);
      REL_TEST(a, k, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->k_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->gamma_from_p_T(p, T, a, b, c);
      REL_TEST(a, gamma, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->gamma_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->gamma_from_v_e(v, e, a, b, c);
      REL_TEST(a, gamma, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->gamma_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->c_from_v_e(v, e, a, b, c);
      REL_TEST(a, ssound, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->c_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    {
      Real a, b, c;
      fp->c_from_p_T(p, T, a, b, c);
      REL_TEST(a, ssound, tol);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->c_from_p_T, p, T, 1e-4, 1e-4);
    }
  }
 
  // test entropy functions
  {
    Real T = 489.305;
    Real Z = 0.5 * (80459 + 80460.7);
    Real p = 1.0e6;
    const Real rho = fp->rho_from_p_T(p, T);
    const Real v = 1.0 / rho;
    const Real v0 = 1.0;
    Real e = fp->e_from_p_T(p, T);
    Real h = fp->h_from_p_T(p, T);
    Real s = Z + Rs * std::log(v / v0);
 
    REL_TEST(fp->s_from_p_T(p, T), s, 1e-6);
    REL_TEST(fp->s_from_v_e(v, e), s, 1e-6);
    REL_TEST(fp->s_from_h_p(h, p), s, 1e-6);
    REL_TEST(fp->s_from_T_v(T, v), s, 1e-6);
 
    // test 5 arg functions with derivatives for s(p, T)
    {
      Real s_alt, ds_dp, ds_dT;
      fp->s_from_p_T(p, T, s_alt, ds_dp, ds_dT);
      REL_TEST(s_alt, s, 1e-5);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_p_T, p, T, 1e-4, 1e-4);
    }
 
    // test 5 arg functions with derivatives for s(e, v)
    {
      Real s_alt, ds_dv, ds_de;
      fp->s_from_v_e(v, e, s_alt, ds_dv, ds_de);
      REL_TEST(s_alt, s, 1e-5);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_v_e, v, e, 1e-4, 1e-4);
    }
 
    // test 5 arg functions with derivatives for s(h, p)
    {
      Real s_alt, ds_dh, ds_dp;
      fp->s_from_h_p(h, p, s_alt, ds_dh, ds_dp);
      REL_TEST(s_alt, s, 1e-5);
      DERIV_TEST_CUSTOM_PERTURBATION(fp->s_from_h_p, h, p, 1e-4, 1e-4);
    }
  }
 
  // test out of bounds call for temperature
  {
    try
    {
      fp->cp_from_p_T(1.0e6, 600.0);
      FAIL();
    }
    catch (const std::exception & err)
    {
      std::size_t pos = std::string(err.what()).find("which is outside of the bounds of");
      ASSERT_TRUE(pos != std::string::npos);
    }
 
    try
    {
      fp->cp_from_p_T(1.0e6, 99.0);
      FAIL();
    }
    catch (const std::exception & err)
    {
      std::size_t pos = std::string(err.what()).find("which is outside of the bounds of");
      ASSERT_TRUE(pos != std::string::npos);
    }
  }
}