https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Functions
TabulatedBicubicFluidPropertiesTest.C File Reference

Go to the source code of this file.

Functions

 TEST_F (TabulatedBicubicFluidPropertiesTest, unorderedData)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, unequalTemperatures)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, missingColumn)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, unknownColumn)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, missingData)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, fromPTFile)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, fromPTFileToVE)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, fromVEGeneratedFromFP)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, derivatives)
 Verify calculation of the derivatives of tabulated properties by comparing with finite differences.
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, generateTabulatedData)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, passthrough)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, passthroughVE)
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, fluidName)
 Test that the fluid name is correctly returned.
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, molarMass)
 Test that the molar mass is correctly returned.
 
 TEST_F (TabulatedBicubicFluidPropertiesTest, combined)
 Verify that the methods that return multiple properties in one call return identical values as the individual methods.
 

Function Documentation

◆ TEST_F() [1/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
combined   
)

Verify that the methods that return multiple properties in one call return identical values as the individual methods.

Definition at line 1134 of file TabulatedBicubicFluidPropertiesTest.C.

1135{
1136 const Real p = 1.0e6;
1137 const Real T = 300.0;
1138 const Real tol = REL_TOL_CONSISTENCY;
1139
1140 // Single property methods
1141 Real rho, drho_dp, drho_dT;
1142 _tab_pT_from_fp->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
1143 Real mu, dmu_dp, dmu_dT;
1144 _tab_pT_from_fp->mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
1145 Real e, de_dp, de_dT;
1146 _tab_pT_from_fp->e_from_p_T(p, T, e, de_dp, de_dT);
1147
1148 // Combined property methods
1149 Real rho2, drho2_dp, drho2_dT, mu2, dmu2_dp, dmu2_dT, e2, de2_dp, de2_dT;
1150 _tab_pT_from_fp->rho_mu_from_p_T(p, T, rho2, mu2);
1151
1152 ABS_TEST(rho, rho2, tol);
1153 ABS_TEST(mu, mu2, tol);
1154
1155 _tab_pT_from_fp->rho_mu_from_p_T(p, T, rho2, drho2_dp, drho2_dT, mu2, dmu2_dp, dmu2_dT);
1156 ABS_TEST(rho, rho2, tol);
1157 ABS_TEST(drho_dp, drho2_dp, tol);
1158 ABS_TEST(drho_dT, drho2_dT, tol);
1159 ABS_TEST(mu, mu2, tol);
1160 ABS_TEST(dmu_dp, dmu2_dp, tol);
1161 ABS_TEST(dmu_dT, dmu2_dT, tol);
1162
1163 _tab_pT_from_fp->rho_e_from_p_T(p, T, rho2, drho2_dp, drho2_dT, e2, de2_dp, de2_dT);
1164 ABS_TEST(rho, rho2, tol);
1165 ABS_TEST(drho_dp, drho2_dp, tol);
1166 ABS_TEST(drho_dT, drho2_dT, tol);
1167 ABS_TEST(e, e2, tol);
1168 ABS_TEST(de_dp, de2_dp, tol);
1169 ABS_TEST(de_dT, de2_dT, tol);
1170}
tol
const double tol
Definition EquilibriumConstantFitTest.C:16
mu
const double mu
Definition GasLiquidMassTransferTest.C:22
p
const Real p
Definition GasLiquidMassTransferTest.C:18
rho
const double rho
Definition GasLiquidMassTransferTest.C:27
T
const double T
Definition GasLiquidMassTransferTest.C:19
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST_F() [2/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
derivatives   
)

Verify calculation of the derivatives of tabulated properties by comparing with finite differences.

Definition at line 888 of file TabulatedBicubicFluidPropertiesTest.C.

889{
890
891 const Real p = 1.5e6;
892 const Real T = 452.0;
893
894 {
895 // Read the data file and generate (v,e) to (p,T) interpolations
896 Moose::_throw_on_warning = false;
897 const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_pT)->initialSetup();
898 Moose::_throw_on_warning = true;
899 const Real tol = REL_TOL_DERIVATIVE;
900
901 const Real rho = _tab_ve_from_pT->rho_from_p_T(p, T);
902 const Real v = 1. / rho;
903 const Real e = _tab_ve_from_pT->e_from_p_T(p, T);
904 const Real s = _tab_ve_from_pT->s_from_p_T(p, T);
905
906 DERIV_TEST(_tab_ve_from_pT->rho_from_p_T, p, T, tol);
907 DERIV_TEST(_tab_ve_from_pT->e_from_p_T, p, T, tol);
908 DERIV_TEST(_tab_ve_from_pT->v_from_p_T, p, T, tol);
909 DERIV_TEST(_tab_ve_from_pT->h_from_p_T, p, T, tol);
910 DERIV_TEST(_tab_ve_from_pT->k_from_p_T, p, T, tol);
911 DERIV_TEST(_tab_ve_from_pT->cp_from_p_T, p, T, tol);
912 DERIV_TEST(_tab_ve_from_pT->cv_from_p_T, p, T, tol);
913 DERIV_TEST(_tab_ve_from_pT->mu_from_p_T, p, T, tol);
914
915 DERIV_TEST(_tab_ve_from_pT->p_from_v_e, v, e, tol);
916 DERIV_TEST(_tab_ve_from_pT->mu_from_v_e, v, e, tol);
917 DERIV_TEST(_tab_ve_from_pT->k_from_v_e, v, e, tol);
918 DERIV_TEST(_tab_ve_from_pT->T_from_v_e, v, e, tol);
919 DERIV_TEST(_tab_ve_from_pT->cp_from_v_e, v, e, tol);
920 DERIV_TEST(_tab_ve_from_pT->cv_from_v_e, v, e, tol);
921
922 DERIV_TEST(_tab_ve_from_pT->T_from_p_rho, p, rho, tol);
923 DERIV_TEST(_tab_ve_from_pT->e_from_p_rho, p, rho, tol);
924
925 DERIV_TEST(_tab_ve_from_pT->T_from_p_s, p, s, tol);
926 DERIV_TEST(_tab_ve_from_pT->rho_from_p_s, p, s, tol);
927 }
928
929 {
930 // Read the data file with direct to (v,e) interpolations
931 Moose::_throw_on_warning = false;
932 const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_fp)->initialSetup();
933 Moose::_throw_on_warning = true;
934 const Real tol = REL_TOL_DERIVATIVE;
935
936 const Real rho = _tab_ve_from_fp->rho_from_p_T(p, T);
937 const Real v = 1. / rho;
938 const Real e = _tab_ve_from_fp->e_from_p_T(p, T);
939 const Real h = e + p * v;
940
941 DERIV_TEST(_tab_ve_from_fp->p_from_v_e, v, e, tol);
942 DERIV_TEST(_tab_ve_from_fp->mu_from_v_e, v, e, tol);
943 DERIV_TEST(_tab_ve_from_fp->k_from_v_e, v, e, tol);
944 DERIV_TEST(_tab_ve_from_fp->T_from_v_e, v, e, tol);
945 DERIV_TEST(_tab_ve_from_fp->cp_from_v_e, v, e, tol);
946 DERIV_TEST(_tab_ve_from_fp->cv_from_v_e, v, e, tol);
947
948 // Jacobian warning and finite differencing in use
949 Moose::_throw_on_warning = false;
950 DERIV_TEST(_tab_ve_from_fp->e_from_v_h, v, h, 100 * tol);
951 Moose::_throw_on_warning = true;
952 }
953}
v
const double v
Definition GasLiquidMassTransferTest.C:23
TabulatedBicubicFluidProperties
Class for fluid properties read from a file.
Definition TabulatedBicubicFluidProperties.h:88
Moose::_throw_on_warning
bool _throw_on_warning

◆ TEST_F() [3/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
fluidName   
)

Test that the fluid name is correctly returned.

Definition at line 1117 of file TabulatedBicubicFluidPropertiesTest.C.

1118{
1119 EXPECT_EQ(_tab_pT_from_fp->fluidName(), "co2");
1120}

◆ TEST_F() [4/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
fromPTFile   
)

Definition at line 107 of file TabulatedBicubicFluidPropertiesTest.C.

108{
109 Real p = 1.5e6;
110 Real T = 450.0;
111
112 // Read the data file
113 const_cast<TabulatedBicubicFluidProperties *>(_tab_pT_from_fp)->initialSetup();
114
115 // Fluid properties
116 REL_TEST(_tab_pT_from_fp->rho_from_p_T(p, T), _co2_fp->rho_from_p_T(p, T), 1.0e-4);
117 REL_TEST(_tab_pT_from_fp->h_from_p_T(p, T), _co2_fp->h_from_p_T(p, T), 1.0e-4);
118 REL_TEST(_tab_pT_from_fp->e_from_p_T(p, T), _co2_fp->e_from_p_T(p, T), 1.0e-4);
119 REL_TEST(_tab_pT_from_fp->mu_from_p_T(p, T), _co2_fp->mu_from_p_T(p, T), 1.0e-4);
120 REL_TEST(_tab_pT_from_fp->k_from_p_T(p, T), _co2_fp->k_from_p_T(p, T), 1.0e-4);
121 REL_TEST(_tab_pT_from_fp->cp_from_p_T(p, T), _co2_fp->cp_from_p_T(p, T), 1.0e-4);
122 REL_TEST(_tab_pT_from_fp->cv_from_p_T(p, T), _co2_fp->cv_from_p_T(p, T), 1.0e-4);
123 REL_TEST(_tab_pT_from_fp->s_from_p_T(p, T), _co2_fp->s_from_p_T(p, T), 1.0e-4);
124
125 // Fluid properties and derivatives
126 Real rho, drho_dp, drho_dT, rhoc, drhoc_dp, drhoc_dT;
127 _tab_pT_from_fp->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
128 _co2_fp->rho_from_p_T(p, T, rhoc, drhoc_dp, drhoc_dT);
129 REL_TEST(rho, rhoc, 1.0e-4);
130 REL_TEST(drho_dp, drhoc_dp, 1.0e-3);
131 REL_TEST(drho_dT, drhoc_dT, 1.0e-3);
132
133 Real h, dh_dp, dh_dT, hc, dhc_dp, dhc_dT;
134 _tab_pT_from_fp->h_from_p_T(p, T, h, dh_dp, dh_dT);
135 _co2_fp->h_from_p_T(p, T, hc, dhc_dp, dhc_dT);
136 REL_TEST(h, hc, 1.0e-4);
137 REL_TEST(dh_dp, dhc_dp, 1.0e-3);
138 REL_TEST(dh_dT, dhc_dT, 1.0e-3);
139
140 Real mu, dmu_dp, dmu_dT, muc, dmuc_dp, dmuc_dT;
141 _tab_pT_from_fp->mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
142 _co2_fp->mu_from_p_T(p, T, muc, dmuc_dp, dmuc_dT);
143 REL_TEST(mu, muc, 1.0e-4);
144 REL_TEST(dmu_dp, dmuc_dp, 1.0e-3);
145 REL_TEST(dmu_dT, dmuc_dT, 1.0e-3);
146
147 Real k, dk_dp, dk_dT, kc, dkc_dp, dkc_dT;
148 _tab_pT_from_fp->k_from_p_T(p, T, k, dk_dp, dk_dT);
149 _co2_fp->k_from_p_T(p, T, kc, dkc_dp, dkc_dT);
150 REL_TEST(k, kc, 1.0e-4);
151 REL_TEST(dk_dp, dkc_dp, 1.0e-3);
152 REL_TEST(dk_dT, dkc_dT, 1.0e-3);
153
154 Real e, de_dp, de_dT, ec, dec_dp, dec_dT;
155 _tab_pT_from_fp->e_from_p_T(p, T, e, de_dp, de_dT);
156 _co2_fp->e_from_p_T(p, T, ec, dec_dp, dec_dT);
157 REL_TEST(e, ec, 1.0e-4);
158 REL_TEST(de_dp, dec_dp, 1.0e-3);
159 REL_TEST(de_dT, dec_dT, 1.0e-3);
160
161 Real s, ds_dp, ds_dT, sc, dsc_dp, dsc_dT;
162 _tab_pT_from_fp->s_from_p_T(p, T, s, ds_dp, ds_dT);
163 _co2_fp->s_from_p_T(p, T, sc, dsc_dp, dsc_dT);
164 REL_TEST(s, sc, 1.0e-4);
165 REL_TEST(ds_dp, dsc_dp, 1.0e-3);
166 REL_TEST(ds_dT, dsc_dT, 1.0e-3);
167}

◆ TEST_F() [5/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
fromPTFileToVE   
)

Definition at line 170 of file TabulatedBicubicFluidPropertiesTest.C.

171{
172 Real p = 1.5e6;
173 Real T = 450.0;
174 Real pert = 1.0e-7;
175
176 // Read the data file
177 Moose::_throw_on_warning = false;
178 const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_pT)->initialSetup();
179 Moose::_throw_on_warning = true;
180
181 // round trip p,T -> v,e -> p,T
182 {
183 Real e = _tab_ve_from_pT->e_from_p_T(p, T);
184 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
185 Real pp = _tab_ve_from_pT->p_from_v_e(v, e);
186 Real TT = _tab_ve_from_pT->T_from_v_e(v, e);
187 ABS_TEST(T, TT, 1.0);
188 REL_TEST(p, pp, 0.001);
189 }
190
191 // check computation of fluid props from p, T & v, e
192 {
193 Real e = _tab_ve_from_pT->e_from_p_T(p, T);
194 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
195
196 // heat capacity at constant pressure
197 Real cp1 = _tab_ve_from_pT->cp_from_p_T(p, T);
198 Real cp2 = _tab_ve_from_pT->cp_from_v_e(v, e);
199 REL_TEST(cp1, cp2, 0.001);
200
201 // heat capacity at constant volume
202 Real cv1 = _tab_ve_from_pT->cv_from_p_T(p, T);
203 Real cv2 = _tab_ve_from_pT->cv_from_v_e(v, e);
204 REL_TEST(cv1, cv2, 0.001);
205
206 // viscosity
207 Real mu1 = _tab_ve_from_pT->mu_from_p_T(p, T);
208 Real mu2 = _tab_ve_from_pT->mu_from_v_e(v, e);
209 REL_TEST(mu1, mu2, 0.001);
210
211 // thermal conductivity
212 Real k1 = _tab_ve_from_pT->k_from_p_T(p, T);
213 Real k2 = _tab_ve_from_pT->k_from_v_e(v, e);
214 REL_TEST(k1, k2, 0.001);
215
216 // enthalpy
217 Real h1 = _tab_ve_from_pT->h_from_p_T(p, T);
218 Real h2 = _tab_ve_from_pT->h_from_v_e(v, e);
219 REL_TEST(h1, h2, 0.001);
220
221 // entropy
222 Real s1 = _tab_ve_from_pT->s_from_p_T(p, T);
223 Real s2 = _tab_ve_from_pT->s_from_v_e(v, e);
224 REL_TEST(s1, s2, 0.001);
225 }
226
227 // check computation of fluid props from p, s
228 {
229 Real s = _tab_ve_from_pT->s_from_p_T(p, T);
230
231 // density
232 Real rho1 = _tab_ve_from_pT->rho_from_p_T(p, T);
233 Real rho2 = _tab_ve_from_pT->rho_from_p_s(p, s);
234 REL_TEST(rho1, rho2, 0.001);
235
236 // temperature
237 Real Ts = _tab_ve_from_pT->T_from_p_s(p, s);
238 REL_TEST(T, Ts, 0.001);
239 }
240
241 // check computation of fluid props from p, rho
242 {
243 Real rho = _tab_ve_from_pT->rho_from_p_T(p, T);
244
245 // specific internal energy
246 Real e1 = _tab_ve_from_pT->e_from_p_T(p, T);
247 Real e2 = _tab_ve_from_pT->e_from_p_rho(p, rho);
248 REL_TEST(e1, e2, REL_TOL_CONSISTENCY);
249 }
250
251 // check computation of fluids props from p, h
252 {
253 Real T = 450;
254 Real p = 1.5e6;
255 Real h = _tab_ve_from_pT->h_from_p_T(p, T);
256 Real Ts = _tab_ve_from_pT->T_from_p_h(p, h);
257 REL_TEST(T, Ts, 1e-4);
258
259 // to keep coverage on the default definition in SinglePhaseFP
260 Ts = dynamic_cast<const SinglePhaseFluidProperties *>(_tab_ve_from_pT)->T_from_p_h(p, h);
261 REL_TEST(T, Ts, 1e-4);
262 }
263
264 // are the two version of functions equivalent
265 {
266 Real e = _tab_ve_from_pT->e_from_p_T(p, T);
267 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
268
269 Real d1, d2;
270
271 // speed of sound errors bc co2 props don't
272 // implement enough
273
274 // heat capacity at constant pressure
275 Real cp1;
276 _tab_ve_from_pT->cp_from_v_e(v, e, cp1, d1, d2);
277 Real cp2 = _tab_ve_from_pT->cp_from_v_e(v, e);
278 REL_TEST(cp1, cp2, 0.001);
279
280 // heat capacity at constant volume
281 Real cv1;
282 _tab_ve_from_pT->cv_from_v_e(v, e, cv1, d1, d2);
283 Real cv2 = _tab_ve_from_pT->cv_from_v_e(v, e);
284 REL_TEST(cv1, cv2, 0.001);
285
286 // viscosity
287 Real mu1;
288 _tab_ve_from_pT->mu_from_v_e(v, e, mu1, d1, d2);
289 Real mu2 = _tab_ve_from_pT->mu_from_v_e(v, e);
290 REL_TEST(mu1, mu2, 0.001);
291
292 // thermal conductivity
293 Real k1;
294 _tab_ve_from_pT->k_from_v_e(v, e, k1, d1, d2);
295 Real k2 = _tab_ve_from_pT->k_from_v_e(v, e);
296 REL_TEST(k1, k2, 0.001);
297 }
298
299 // check derivatives
300 {
301 Real e = _tab_ve_from_pT->e_from_p_T(p, T);
302 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
303
304 Real deriv1, deriv2;
305
306 // pressure
307 Real p1;
308 _tab_ve_from_pT->p_from_v_e(v, e, p1, deriv1, deriv2);
309 Real p2 = _tab_ve_from_pT->p_from_v_e(v, e);
310 REL_TEST(p1, p2, 0.001);
311
312 // temperature
313 Real T1;
314 _tab_ve_from_pT->T_from_v_e(v, e, T1, deriv1, deriv2);
315 Real T2 = _tab_ve_from_pT->T_from_v_e(v, e);
316 REL_TEST(T1, T2, 0.001);
317
318 // speed of sound errors bc co2 props don't
319 // implement enough
320
321 // heat capacity at constant pressure
322 Real cp1;
323 _tab_ve_from_pT->cp_from_v_e(v, e, cp1, deriv1, deriv2);
324 Real cp_0 = _tab_ve_from_pT->cp_from_v_e(v, e);
325 Real cp_1 = _tab_ve_from_pT->cp_from_v_e(v * (1 + pert), e);
326 Real cp_2 = _tab_ve_from_pT->cp_from_v_e(v, e * (1 + pert));
327 REL_TEST(deriv1, (cp_1 - cp_0) / (v * pert), 0.001);
328 REL_TEST(deriv2, (cp_2 - cp_0) / (e * pert), 0.001);
329
330 // heat capacity at constant volume
331 Real cv1;
332 _tab_ve_from_pT->cv_from_v_e(v, e, cv1, deriv1, deriv2);
333 Real cv_0 = _tab_ve_from_pT->cv_from_v_e(v, e);
334 Real cv_1 = _tab_ve_from_pT->cv_from_v_e(v * (1 + pert), e);
335 Real cv_2 = _tab_ve_from_pT->cv_from_v_e(v, e * (1 + pert));
336 REL_TEST(deriv1, (cv_1 - cv_0) / (v * pert), 0.001);
337 REL_TEST(deriv2, (cv_2 - cv_0) / (e * pert), 0.001);
338
339 // viscosity
340 Real mu1;
341 _tab_ve_from_pT->mu_from_v_e(v, e, mu1, deriv1, deriv2);
342 Real mu_0 = _tab_ve_from_pT->mu_from_v_e(v, e);
343 Real mu_1 = _tab_ve_from_pT->mu_from_v_e(v * (1 + pert), e);
344 Real mu_2 = _tab_ve_from_pT->mu_from_v_e(v, e * (1 + pert));
345 REL_TEST(deriv1, (mu_1 - mu_0) / (v * pert), 0.001);
346 REL_TEST(deriv2, (mu_2 - mu_0) / (e * pert), 0.001);
347
348 // thermal conductivity
349 Real k1;
350 _tab_ve_from_pT->k_from_v_e(v, e, k1, deriv1, deriv2);
351 Real k_0 = _tab_ve_from_pT->k_from_v_e(v, e);
352 Real k_1 = _tab_ve_from_pT->k_from_v_e(v * (1 + pert), e);
353 Real k_2 = _tab_ve_from_pT->k_from_v_e(v, e * (1 + pert));
354 REL_TEST(deriv1, (k_1 - k_0) / (v * pert), 0.001);
355 REL_TEST(deriv2, (k_2 - k_0) / (e * pert), 0.001);
356 }
357
358 // test enthalpy relationships
359 {
360 Real h = _tab_ve_from_pT->h_from_p_T(p, T);
361 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
362 Real e_gold = _tab_ve_from_pT->e_from_p_T(p, T);
363 Real e = _tab_ve_from_pT->e_from_v_h(v, h);
364 REL_TEST(e_gold, e, 0.001);
365
366 Real e2, de_dv, de_dh;
367 _tab_ve_from_pT->e_from_v_h(v, h, e2, de_dv, de_dh);
368 REL_TEST(e_gold, e2, 0.001);
369 Real e_0 = _tab_ve_from_pT->e_from_v_h(v, h);
370 Real e_1 = _tab_ve_from_pT->e_from_v_h(v * (1 + pert), h);
371 Real e_2 = _tab_ve_from_pT->e_from_v_h(v, h * (1 + pert));
372 REL_TEST(de_dv, (e_1 - e_0) / (v * pert), 0.001);
373 REL_TEST(de_dh, (e_2 - e_0) / (h * pert), 0.001);
374 }
375
376 // AD p_from_v_e
377 {
378 Real e = _tab_ve_from_pT->e_from_p_T(p, T);
379 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
380 DNDerivativeType dvdx;
381 DNDerivativeType dedx;
382 // set it up so these are the derivatives
383 // w.r.t. to themselves
384 Moose::derivInsert(dvdx, 0, 1);
385 Moose::derivInsert(dvdx, 1, 0);
386 Moose::derivInsert(dedx, 0, 0);
387 Moose::derivInsert(dedx, 1, 1);
388
389 ADReal v_ad(v, dvdx);
390 ADReal e_ad(e, dedx);
391 ADReal p_ad = _tab_ve_from_pT->p_from_v_e(v_ad, e_ad);
392
393 Real pp, dp_dv, dp_de;
394 _tab_ve_from_pT->p_from_v_e(v, e, pp, dp_dv, dp_de);
395 REL_TEST(p_ad.derivatives()[0], dp_dv, 0.0001);
396 REL_TEST(p_ad.derivatives()[1], dp_de, 0.0001);
397
398 ADReal ad_pp, ad_dp_dv, ad_dp_de;
399 _tab_ve_from_pT->p_from_v_e(v_ad, e_ad, ad_pp, ad_dp_dv, ad_dp_de);
400 REL_TEST(p_ad.derivatives()[0], ad_dp_dv.value(), 0.0001);
401 REL_TEST(p_ad.derivatives()[1], ad_dp_de.value(), 0.0001);
402 }
403
404 // AD T_from_v_e
405 {
406 Real e = _tab_ve_from_pT->e_from_p_T(p, T);
407 Real v = _tab_ve_from_pT->v_from_p_T(p, T);
408 DNDerivativeType dvdx;
409 DNDerivativeType dedx;
410 // set it up so these are the derivatives
411 // w.r.t. to themselves
412 Moose::derivInsert(dvdx, 0, 1);
413 Moose::derivInsert(dvdx, 1, 0);
414 Moose::derivInsert(dedx, 0, 0);
415 Moose::derivInsert(dedx, 1, 1);
416
417 ADReal v_ad(v, dvdx);
418 ADReal e_ad(e, dedx);
419 ADReal T_ad = _tab_ve_from_pT->T_from_v_e(v_ad, e_ad);
420
421 Real TT, dT_dv, dT_de;
422 _tab_ve_from_pT->T_from_v_e(v, e, TT, dT_dv, dT_de);
423 REL_TEST(T_ad.derivatives()[0], dT_dv, 0.0001);
424 REL_TEST(T_ad.derivatives()[1], dT_de, 0.0001);
425
426 ADReal ad_TT, ad_dT_dv, ad_dT_de;
427 _tab_ve_from_pT->T_from_v_e(v_ad, e_ad, ad_TT, ad_dT_dv, ad_dT_de);
428 REL_TEST(T_ad.derivatives()[0], ad_dT_dv.value(), 0.0001);
429 REL_TEST(T_ad.derivatives()[1], ad_dT_de.value(), 0.0001);
430 }
431
432 // cannot test AD c_from_v_e because co2 props do not
433 // implement enough
434
435 // AD T_from_p_h
436 {
437 Real h = _tab_ve_from_pT->h_from_p_T(p, T);
438 DNDerivativeType dpdx;
439 DNDerivativeType dhdx;
440 // set it up so these are the derivatives
441 // w.r.t. to themselves
442 Moose::derivInsert(dpdx, 0, 1);
443 Moose::derivInsert(dpdx, 1, 0);
444 Moose::derivInsert(dhdx, 0, 0);
445 Moose::derivInsert(dhdx, 1, 1);
446
447 ADReal p_ad(p, dpdx);
448 ADReal h_ad(h, dhdx);
449 ADReal T_ad = _tab_ve_from_pT->T_from_p_h(p_ad, h_ad);
450
451 Real TT_1 = _tab_ve_from_pT->T_from_p_h(p * (1 + pert), h);
452 Real TT_2 = _tab_ve_from_pT->T_from_p_h(p, h * (1 + pert));
453 Real dT_dp = (TT_1 - T) / p / pert;
454 Real dT_dh = (TT_2 - T) / h / pert;
455 REL_TEST(T_ad.derivatives()[0], dT_dp, 0.0001);
456 REL_TEST(T_ad.derivatives()[1], dT_dh, 0.0001);
457 }
458
459 // AD rho_from_p_T
460 {
461 DNDerivativeType dpdx;
462 DNDerivativeType dTdx;
463 // set it up so these are the derivatives
464 // w.r.t. to themselves
465 Moose::derivInsert(dpdx, 0, 1);
466 Moose::derivInsert(dpdx, 1, 0);
467 Moose::derivInsert(dTdx, 0, 0);
468 Moose::derivInsert(dTdx, 1, 1);
469
470 ADReal p_ad(p, dpdx);
471 ADReal T_ad(T, dTdx);
472 ADReal rho_ad = _tab_ve_from_pT->rho_from_p_T(p_ad, T_ad);
473
474 Real rho, drho_dp, drho_dT;
475 _tab_ve_from_pT->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
476 REL_TEST(rho_ad.derivatives()[0], drho_dp, 0.0001);
477 REL_TEST(rho_ad.derivatives()[1], drho_dT, 0.0001);
478
479 ADReal ad_rho, ad_drho_dp, ad_drho_dT;
480 _tab_ve_from_pT->rho_from_p_T(p_ad, T_ad, ad_rho, ad_drho_dp, ad_drho_dT);
481 REL_TEST(rho_ad.derivatives()[0], ad_drho_dp.value(), 0.0001);
482 REL_TEST(rho_ad.derivatives()[1], ad_drho_dT.value(), 0.0001);
483 }
484
485 // AD e_from_p_T
486 {
487 DNDerivativeType dpdx;
488 DNDerivativeType dTdx;
489 // set it up so these are the derivatives
490 // w.r.t. to themselves
491 Moose::derivInsert(dpdx, 0, 1);
492 Moose::derivInsert(dpdx, 1, 0);
493 Moose::derivInsert(dTdx, 0, 0);
494 Moose::derivInsert(dTdx, 1, 1);
495
496 ADReal p_ad(p, dpdx);
497 ADReal T_ad(T, dTdx);
498 ADReal e_ad = _tab_ve_from_pT->e_from_p_T(p_ad, T_ad);
499
500 Real e, de_dp, de_dT;
501 _tab_ve_from_pT->e_from_p_T(p, T, e, de_dp, de_dT);
502 REL_TEST(e_ad.derivatives()[0], de_dp, 0.0001);
503 REL_TEST(e_ad.derivatives()[1], de_dT, 0.0001);
504 }
505
506 // AD v_from_p_T
507 {
508 DNDerivativeType dpdx;
509 DNDerivativeType dTdx;
510 // set it up so these are the derivatives
511 // w.r.t. to themselves
512 Moose::derivInsert(dpdx, 0, 1);
513 Moose::derivInsert(dpdx, 1, 0);
514 Moose::derivInsert(dTdx, 0, 0);
515 Moose::derivInsert(dTdx, 1, 1);
516
517 ADReal p_ad(p, dpdx);
518 ADReal T_ad(T, dTdx);
519 ADReal v_ad = _tab_ve_from_pT->v_from_p_T(p_ad, T_ad);
520
521 Real v, dv_dp, dv_dT;
522 _tab_ve_from_pT->v_from_p_T(p, T, v, dv_dp, dv_dT);
523 REL_TEST(v_ad.derivatives()[0], dv_dp, 0.0001);
524 REL_TEST(v_ad.derivatives()[1], dv_dT, 0.0001);
525 }
526}
ADReal
DualNumber< Real, DNDerivativeType, true > ADReal
DNDerivativeType
SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< MOOSE_AD_MAX_DOFS_PER_ELEM > > DNDerivativeType
SinglePhaseFluidProperties
Common class for single phase fluid properties.
Definition SinglePhaseFluidProperties.h:115
Moose::derivInsert
void derivInsert(SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< N > > &derivs, libMesh::dof_id_type index, Real value)

◆ TEST_F() [6/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
fromVEGeneratedFromFP   
)

Definition at line 529 of file TabulatedBicubicFluidPropertiesTest.C.

530{
531 // These values must be within the bounds specified in the header
532 Real p = 1.223e6;
533 Real T = 420.1;
534 Real pert = 1.0e-7;
535
536 // Generate the (v, e) tabulation from the FP user object
537 const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_fp)->initialSetup();
538
539 // Use as a reference
540 Real e = _idg_fp->e_from_p_T(p, T);
541 Real v = _idg_fp->v_from_p_T(p, T);
542
543 // check computation of fluid props from v, e
544 {
545 // heat capacity at constant pressure
546 Real cp1 = _idg_fp->cp_from_v_e(v, e);
547 Real cp2 = _tab_ve_from_fp->cp_from_v_e(v, e);
548 REL_TEST(cp1, cp2, 0.001);
549
550 // heat capacity at constant volume
551 Real cv1 = _idg_fp->cv_from_v_e(v, e);
552 Real cv2 = _tab_ve_from_fp->cv_from_v_e(v, e);
553 REL_TEST(cv1, cv2, 0.001);
554
555 // speed of sound
556 Real c1 = _idg_fp->c_from_v_e(v, e);
557 Real c2 = _tab_ve_from_fp->c_from_v_e(v, e);
558 REL_TEST(c1, c2, 0.001);
559
560 // viscosity
561 Real mu1 = _idg_fp->mu_from_v_e(v, e);
562 Real mu2 = _tab_ve_from_fp->mu_from_v_e(v, e);
563 REL_TEST(mu1, mu2, 0.001);
564
565 // thermal conductivity
566 Real k1 = _idg_fp->k_from_v_e(v, e);
567 Real k2 = _tab_ve_from_fp->k_from_v_e(v, e);
568 REL_TEST(k1, k2, 0.001);
569 }
570
571 // are the two version of functions equivalent
572 {
573 Real d1, d2;
574
575 // pressure
576 Real p1;
577 _tab_ve_from_fp->p_from_v_e(v, e, p1, d1, d2);
578 Real p2 = _tab_ve_from_fp->p_from_v_e(v, e);
579 REL_TEST(p1, p2, 0.001);
580
581 // temperature
582 Real T1;
583 _tab_ve_from_fp->T_from_v_e(v, e, T1, d1, d2);
584 Real T2 = _tab_ve_from_fp->T_from_v_e(v, e);
585 REL_TEST(T1, T2, 0.001);
586
587 // heat capacity at constant pressure
588 Real cp1;
589 _tab_ve_from_fp->cp_from_v_e(v, e, cp1, d1, d2);
590 Real cp2 = _tab_ve_from_fp->cp_from_v_e(v, e);
591 REL_TEST(cp1, cp2, 0.001);
592
593 // heat capacity at constant volume
594 Real cv1;
595 _tab_ve_from_fp->cv_from_v_e(v, e, cv1, d1, d2);
596 Real cv2 = _tab_ve_from_fp->cv_from_v_e(v, e);
597 REL_TEST(cv1, cv2, 0.001);
598
599 // speed of sound
600 Real c1;
601 _tab_ve_from_fp->c_from_v_e(v, e, c1, d1, d2);
602 Real c2 = _tab_ve_from_fp->c_from_v_e(v, e);
603 REL_TEST(c1, c2, 0.001);
604
605 // viscosity
606 Real mu1;
607 _tab_ve_from_fp->mu_from_v_e(v, e, mu1, d1, d2);
608 Real mu2 = _tab_ve_from_fp->mu_from_v_e(v, e);
609 REL_TEST(mu1, mu2, 0.001);
610
611 // thermal conductivity
612 Real k1;
613 _tab_ve_from_fp->k_from_v_e(v, e, k1, d1, d2);
614 Real k2 = _tab_ve_from_fp->k_from_v_e(v, e);
615 REL_TEST(k1, k2, 0.001);
616 }
617
618 // check derivatives
619 {
620 Real deriv1, deriv2;
621
622 // speed of sound errors bc co2 props don't
623 // implement enough
624
625 // heat capacity at constant pressure
626 Real cp1;
627 _tab_ve_from_fp->cp_from_v_e(v, e, cp1, deriv1, deriv2);
628 Real cp_0 = _tab_ve_from_fp->cp_from_v_e(v, e);
629 Real cp_1 = _tab_ve_from_fp->cp_from_v_e(v * (1 + pert), e);
630 Real cp_2 = _tab_ve_from_fp->cp_from_v_e(v, e * (1 + pert));
631 REL_TEST(cp1, cp_0, 0.001);
632 REL_TEST(deriv1, (cp_1 - cp_0) / (v * pert), 0.001);
633 REL_TEST(deriv2, (cp_2 - cp_0) / (e * pert), 0.001);
634
635 // heat capacity at constant volume
636 Real cv1;
637 _tab_ve_from_fp->cv_from_v_e(v, e, cv1, deriv1, deriv2);
638 Real cv_0 = _tab_ve_from_fp->cv_from_v_e(v, e);
639 Real cv_1 = _tab_ve_from_fp->cv_from_v_e(v * (1 + pert), e);
640 Real cv_2 = _tab_ve_from_fp->cv_from_v_e(v, e * (1 + pert));
641 REL_TEST(cv1, cv_0, 0.001);
642 REL_TEST(deriv1, (cv_1 - cv_0) / (v * pert), 0.001);
643 REL_TEST(deriv2, (cv_2 - cv_0) / (e * pert), 0.001);
644
645 // viscosity
646 Real mu1;
647 _tab_ve_from_fp->mu_from_v_e(v, e, mu1, deriv1, deriv2);
648 Real mu_0 = _tab_ve_from_fp->mu_from_v_e(v, e);
649 Real mu_1 = _tab_ve_from_fp->mu_from_v_e(v * (1 + pert), e);
650 Real mu_2 = _tab_ve_from_fp->mu_from_v_e(v, e * (1 + pert));
651 REL_TEST(mu1, mu_0, 0.001);
652 REL_TEST(deriv1, (mu_1 - mu_0) / (v * pert), 0.001);
653 REL_TEST(deriv2, (mu_2 - mu_0) / (e * pert), 0.001);
654
655 // thermal conductivity
656 Real k1;
657 _tab_ve_from_fp->k_from_v_e(v, e, k1, deriv1, deriv2);
658 Real k_0 = _tab_ve_from_fp->k_from_v_e(v, e);
659 Real k_1 = _tab_ve_from_fp->k_from_v_e(v * (1 + pert), e);
660 Real k_2 = _tab_ve_from_fp->k_from_v_e(v, e * (1 + pert));
661 REL_TEST(k1, k_0, 0.001);
662 REL_TEST(deriv1, (k_1 - k_0) / (v * pert), 0.001);
663 REL_TEST(deriv2, (k_2 - k_0) / (e * pert), 0.001);
664
665 // entropy
666 Real s1;
667 _tab_ve_from_fp->s_from_v_e(v, e, s1, deriv1, deriv2);
668 Real s_0 = _tab_ve_from_fp->s_from_v_e(v, e);
669 Real s_1 = _tab_ve_from_fp->s_from_v_e(v * (1 + pert), e);
670 Real s_2 = _tab_ve_from_fp->s_from_v_e(v, e * (1 + pert));
671 REL_TEST(s1, s_0, 0.001);
672 REL_TEST(deriv1, (s_1 - s_0) / (v * pert), 0.001);
673 REL_TEST(deriv2, (s_2 - s_0) / (e * pert), 0.001);
674 }
675
676 // test enthalpy relationships (v,h)
677 {
678 Moose::_throw_on_warning = false;
679 Real h = _idg_fp->h_from_p_T(p, T);
680 Real v = _idg_fp->v_from_p_T(p, T);
681 Real e_gold = _idg_fp->e_from_p_T(p, T);
682 Real e0 = _tab_ve_from_fp->e_from_v_h(v, h);
683 REL_TEST(e_gold, e0, 0.001);
684
685 Real e2, de_dv, de_dh;
686 _tab_ve_from_fp->e_from_v_h(v, h, e2, de_dv, de_dh);
687 REL_TEST(e_gold, e2, 0.001);
688 Real e_0 = _tab_ve_from_fp->e_from_v_h(v, h);
689 Real e_1 = _tab_ve_from_fp->e_from_v_h(v * (1 + pert), h);
690 Real e_2 = _tab_ve_from_fp->e_from_v_h(v, h * (1 + pert));
691 REL_TEST(de_dv, (e_1 - e_0) / (v * pert), 0.001);
692 REL_TEST(de_dh, (e_2 - e_0) / (h * pert), 0.001);
693 Moose::_throw_on_warning = true;
694 }
695
696 // check computations from p, T
697 {
698 // density
699 Real p = _tab_ve_from_fp->p_from_v_e(v, e);
700 Real T = _tab_ve_from_fp->T_from_v_e(v, e);
701 REL_TEST(1. / v, _tab_ve_from_fp->rho_from_p_T(p, T), 1e-6);
702
703 // internal energy
704 REL_TEST(e, _tab_ve_from_fp->e_from_p_T(p, T), 1e-6);
705
706 // enthalpy
707 Real h = _tab_ve_from_fp->h_from_v_e(v, e);
708 REL_TEST(h, _tab_ve_from_fp->h_from_p_T(p, T), 1e-6);
709
710 // entropy
711 Real s = _tab_ve_from_fp->s_from_v_e(v, e);
712 REL_TEST(s, _tab_ve_from_fp->s_from_p_T(p, T), 1e-6);
713 }
714
715 // check computations from p, rho
716 {
717 // temperature
718 Real p = _tab_ve_from_fp->p_from_v_e(v, e);
719 Real T = _tab_ve_from_fp->T_from_v_e(v, e);
720 REL_TEST(T, _tab_ve_from_fp->T_from_p_rho(p, 1. / v), 1e-6);
721
722 // specific internal energy
723 REL_TEST(e, _tab_ve_from_fp->e_from_p_rho(p, 1. / v), 1e-6);
724 }
725
726 // check computations from p, h
727 {
728 // temperature
729 Real p = _tab_ve_from_fp->p_from_v_e(v, e);
730 Real T = _tab_ve_from_fp->T_from_v_e(v, e);
731 Real h = _tab_ve_from_fp->h_from_v_e(v, e);
732 REL_TEST(T, _tab_ve_from_fp->T_from_p_h(p, h), 1e-6);
733
734 // entropy
735 Real s = _tab_ve_from_fp->s_from_v_e(v, e);
736 REL_TEST(s, _tab_ve_from_fp->s_from_h_p(h, p), 1e-6);
737 }
738
739 // check computations from p, s
740 {
741 // temperature
742 Real p = _tab_ve_from_fp->p_from_v_e(v, e);
743 Real T = _tab_ve_from_fp->T_from_v_e(v, e);
744 Real s = _tab_ve_from_fp->s_from_v_e(v, e);
745 Moose::_throw_on_warning = false;
746 REL_TEST(T, _tab_ve_from_fp->T_from_p_s(p, s), 1e-6);
747 Moose::_throw_on_warning = true;
748 }
749
750 // AD p_from_v_e
751 {
752 DNDerivativeType dvdx;
753 DNDerivativeType dedx;
754 // set it up so these are the derivatives
755 // w.r.t. to themselves
756 Moose::derivInsert(dvdx, 0, 1);
757 Moose::derivInsert(dvdx, 1, 0);
758 Moose::derivInsert(dedx, 0, 0);
759 Moose::derivInsert(dedx, 1, 1);
760
761 ADReal v_ad(v, dvdx);
762 ADReal e_ad(e, dedx);
763 ADReal p_ad = _tab_ve_from_fp->p_from_v_e(v_ad, e_ad);
764
765 Real pp, dp_dv, dp_de;
766 _tab_ve_from_fp->p_from_v_e(v, e, pp, dp_dv, dp_de);
767 REL_TEST(p_ad.derivatives()[0], dp_dv, 0.0001);
768 REL_TEST(p_ad.derivatives()[1], dp_de, 0.0001);
769 }
770
771 // AD T_from_v_e
772 {
773 DNDerivativeType dvdx;
774 DNDerivativeType dedx;
775 // set it up so these are the derivatives
776 // w.r.t. to themselves
777 Moose::derivInsert(dvdx, 0, 1);
778 Moose::derivInsert(dvdx, 1, 0);
779 Moose::derivInsert(dedx, 0, 0);
780 Moose::derivInsert(dedx, 1, 1);
781
782 ADReal v_ad(v, dvdx);
783 ADReal e_ad(e, dedx);
784 ADReal T_ad = _tab_ve_from_fp->T_from_v_e(v_ad, e_ad);
785
786 Real TT, dT_dv, dT_de;
787 _tab_ve_from_fp->T_from_v_e(v, e, TT, dT_dv, dT_de);
788 REL_TEST(T_ad.derivatives()[0], dT_dv, 0.0001);
789 REL_TEST(T_ad.derivatives()[1], dT_de, 0.0001);
790 }
791
792 // AD e_from_p_rho
793 {
794 DNDerivativeType dpdx;
795 DNDerivativeType drhodx;
796 // set it up so these are the derivatives
797 // w.r.t. to themselves
798 Moose::derivInsert(dpdx, 0, 1);
799 Moose::derivInsert(dpdx, 1, 0);
800 Moose::derivInsert(drhodx, 0, 0);
801 Moose::derivInsert(drhodx, 1, 1);
802
803 Real rho = 1. / v;
804 ADReal p_ad(p, dpdx);
805 ADReal rho_ad(rho, drhodx);
806 ADReal e_ad = _tab_ve_from_fp->e_from_p_rho(p_ad, rho_ad);
807
808 Real e, de_dp, de_drho;
809 _tab_ve_from_fp->e_from_p_rho(p, rho, e, de_dp, de_drho);
810 REL_TEST(e_ad.derivatives()[0], de_dp, 0.0001);
811 REL_TEST(e_ad.derivatives()[1], de_drho, 0.0001);
812 }
813
814 // AD T_from_p_rho
815 {
816 DNDerivativeType dpdx;
817 DNDerivativeType drhodx;
818 // set it up so these are the derivatives
819 // w.r.t. to themselves
820 Moose::derivInsert(dpdx, 0, 1);
821 Moose::derivInsert(dpdx, 1, 0);
822 Moose::derivInsert(drhodx, 0, 0);
823 Moose::derivInsert(drhodx, 1, 1);
824
825 Real rho = 1. / v;
826 ADReal p_ad(p, dpdx);
827 ADReal rho_ad(rho, drhodx);
828 ADReal T_ad = _tab_ve_from_fp->T_from_p_rho(p_ad, rho_ad);
829
830 Real T, dT_dp, dT_drho;
831 _tab_ve_from_fp->T_from_p_rho(p, rho, T, dT_dp, dT_drho);
832 REL_TEST(T_ad.derivatives()[0], dT_dp, 0.0001);
833 REL_TEST(T_ad.derivatives()[1], dT_drho, 0.0001);
834 }
835
836 // AD e_from_p_T
837 {
838 DNDerivativeType dpdx;
839 DNDerivativeType dTdx;
840 // set it up so these are the derivatives
841 // w.r.t. to themselves
842 Moose::derivInsert(dpdx, 0, 1);
843 Moose::derivInsert(dpdx, 1, 0);
844 Moose::derivInsert(dTdx, 0, 0);
845 Moose::derivInsert(dTdx, 1, 1);
846
847 ADReal p_ad(p, dpdx);
848 ADReal T_ad(T, dTdx);
849 ADReal e_ad = _tab_ve_from_fp->e_from_p_T(p_ad, T_ad);
850
851 Real e, de_dp, de_dT;
852 _tab_ve_from_fp->e_from_p_T(p, T, e, de_dp, de_dT);
853 REL_TEST(e_ad.derivatives()[0], de_dp, 0.0001);
854 REL_TEST(e_ad.derivatives()[1], de_dT, 0.0001);
855 }
856
857 // AD rho_from_p_T
858 {
859 DNDerivativeType dpdx;
860 DNDerivativeType dTdx;
861 // set it up so these are the derivatives
862 // w.r.t. to themselves
863 Moose::derivInsert(dpdx, 0, 1);
864 Moose::derivInsert(dpdx, 1, 0);
865 Moose::derivInsert(dTdx, 0, 0);
866 Moose::derivInsert(dTdx, 1, 1);
867
868 Real p = _tab_ve_from_fp->p_from_v_e(v, e);
869 Real T = _tab_ve_from_fp->p_from_v_e(v, e);
870 ADReal p_ad(p, dpdx);
871 ADReal T_ad(T, dTdx);
872 ADReal rho_ad = _tab_ve_from_fp->rho_from_p_T(p_ad, T_ad);
873
874 Real rho, drho_dp, drho_dT;
875 _tab_ve_from_fp->rho_from_p_T(p, T, rho, drho_dp, drho_dT);
876 REL_TEST(rho_ad.derivatives()[0], drho_dp, 0.0001);
877 REL_TEST(rho_ad.derivatives()[1], drho_dT, 0.0001);
878 }
879
880 // cannot test AD c_from_v_e because co2 props do not
881 // implement enough
882}

◆ TEST_F() [7/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
generateTabulatedData   
)

Definition at line 956 of file TabulatedBicubicFluidPropertiesTest.C.

957{
958 Real p = 1.5e6;
959 Real T = 450.0;
960
961 // Generate the tabulated data from the CO2 fluid properties
962 const_cast<TabulatedBicubicFluidProperties *>(_tab_pT_from_fp_gen)->initialSetup();
963
964 REL_TEST(_tab_pT_from_fp_gen->rho_from_p_T(p, T), _co2_fp->rho_from_p_T(p, T), 1.0e-4);
965 REL_TEST(_tab_pT_from_fp_gen->h_from_p_T(p, T), _co2_fp->h_from_p_T(p, T), 1.0e-4);
966 REL_TEST(_tab_pT_from_fp_gen->e_from_p_T(p, T), _co2_fp->e_from_p_T(p, T), 1.0e-4);
967 REL_TEST(_tab_pT_from_fp_gen->mu_from_p_T(p, T), _co2_fp->mu_from_p_T(p, T), 1.0e-4);
968 REL_TEST(_tab_pT_from_fp_gen->k_from_p_T(p, T), _co2_fp->k_from_p_T(p, T), 1.0e-4);
969 REL_TEST(_tab_pT_from_fp_gen->cp_from_p_T(p, T), _co2_fp->cp_from_p_T(p, T), 1.0e-4);
970 REL_TEST(_tab_pT_from_fp_gen->cv_from_p_T(p, T), _co2_fp->cv_from_p_T(p, T), 1.0e-4);
971 REL_TEST(_tab_pT_from_fp_gen->s_from_p_T(p, T), _co2_fp->s_from_p_T(p, T), 1.0e-4);
972}

◆ TEST_F() [8/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
missingColumn   
)

Definition at line 52 of file TabulatedBicubicFluidPropertiesTest.C.

53{
54 try
55 {
56 const auto tow = Moose::_throw_on_warning;
57 Moose::_throw_on_warning = true;
58 const_cast<TabulatedBicubicFluidProperties *>(_missing_col_fp)->initialSetup();
59 Moose::_throw_on_warning = tow;
60 FAIL();
61 }
62 catch (const std::exception & err)
63 {
64 std::size_t pos = std::string(err.what())
65 .find("data/csv/missing_col_fluid_props.csv. A "
66 "column named temperature must be present");
67 ASSERT_TRUE(pos != std::string::npos);
68 }
69}
libMesh::err
OStreamProxy err(std::cerr)

◆ TEST_F() [9/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
missingData   
)

Definition at line 89 of file TabulatedBicubicFluidPropertiesTest.C.

90{
91 try
92 {
93 const_cast<TabulatedBicubicFluidProperties *>(_missing_data_fp)->initialSetup();
94 FAIL();
95 }
96 catch (const std::exception & err)
97 {
98 std::size_t pos = std::string(err.what())
99 .find("data/csv/missing_data_fluid_props.csv "
100 "is not equal to the number of unique pressure values 3 multiplied "
101 "by the number of unique temperature values 3");
102 ASSERT_TRUE(pos != std::string::npos);
103 }
104}

◆ TEST_F() [10/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
molarMass   
)

Test that the molar mass is correctly returned.

Definition at line 1125 of file TabulatedBicubicFluidPropertiesTest.C.

1126{
1127 ABS_TEST(_tab_pT_from_fp->molarMass(), 44.0098e-3, REL_TOL_SAVED_VALUE);
1128}

◆ TEST_F() [11/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
passthrough   
)

Definition at line 976 of file TabulatedBicubicFluidPropertiesTest.C.

977{
978 Real p = 1.5e6;
979 Real T = 450.0;
980 const Real tol = REL_TOL_SAVED_VALUE;
981
982 // As the flags for interpolation in TabulatedBicubicFluidProperties default to false,
983 // properties will be passed through to the given fluid properties object
984 ABS_TEST(_tab_pT_from_fp->v_from_p_T(p, T), 1. / _co2_fp->rho_from_p_T(p, T), tol);
985 ABS_TEST(_tab_pT_from_fp->rho_from_p_T(p, T), _co2_fp->rho_from_p_T(p, T), tol);
986 ABS_TEST(_tab_pT_from_fp->h_from_p_T(p, T), _co2_fp->h_from_p_T(p, T), tol);
987 ABS_TEST(_tab_pT_from_fp->e_from_p_T(p, T), _co2_fp->e_from_p_T(p, T), tol);
988 ABS_TEST(_tab_pT_from_fp->mu_from_p_T(p, T), _co2_fp->mu_from_p_T(p, T), tol);
989 ABS_TEST(_tab_pT_from_fp->k_from_p_T(p, T), _co2_fp->k_from_p_T(p, T), tol);
990 ABS_TEST(_tab_pT_from_fp->cp_from_p_T(p, T), _co2_fp->cp_from_p_T(p, T), tol);
991 ABS_TEST(_tab_pT_from_fp->cv_from_p_T(p, T), _co2_fp->cv_from_p_T(p, T), tol);
992 ABS_TEST(_tab_pT_from_fp->s_from_p_T(p, T), _co2_fp->s_from_p_T(p, T), tol);
993
994 // These calls are always forwarded to the 'fp' parameter fluid properties because the
995 // tabulations are not implemented
996 ABS_TEST(_tab_pT_from_fp->henryCoefficients()[0], _co2_fp->henryCoefficients()[0], tol);
997 ABS_TEST(_tab_pT_from_fp->henryCoefficients()[1], _co2_fp->henryCoefficients()[1], tol);
998 ABS_TEST(_tab_pT_from_fp->henryCoefficients()[2], _co2_fp->henryCoefficients()[2], tol);
999 ABS_TEST(_tab_pT_from_fp->triplePointPressure(), _co2_fp->triplePointPressure(), tol);
1000 ABS_TEST(_tab_pT_from_fp->triplePointTemperature(), _co2_fp->triplePointTemperature(), tol);
1001 ABS_TEST(_tab_pT_from_fp->criticalPressure(), _co2_fp->criticalPressure(), tol);
1002 ABS_TEST(_tab_pT_from_fp->criticalTemperature(), _co2_fp->criticalTemperature(), tol);
1003 ABS_TEST(_tab_pT_from_fp->criticalDensity(), _co2_fp->criticalDensity(), tol);
1004
1005 // Use a temperature less than the critical point
1006 T = 300.0;
1007 ABS_TEST(_tab_pT_from_fp->vaporPressure(T), _co2_fp->vaporPressure(T), tol);
1008
1009 // TODO: these properties are not implemented in CO2 fp so we cannot test the pass through
1010 // T_from_p_h
1011 // vaporPressure with saturation pressure
1012 // vaporTemperature
1013
1014 // AD passthrough
1015 // Switching to IdealGas FP to have more definitions
1016 const_cast<TabulatedBicubicFluidProperties *>(_tab_pT_from_fp_idg)->initialSetup();
1017 DNDerivativeType dpdx;
1018 DNDerivativeType dTdx;
1019 Moose::derivInsert(dpdx, 0, 1);
1020 Moose::derivInsert(dpdx, 1, 0);
1021 Moose::derivInsert(dTdx, 0, 0);
1022 Moose::derivInsert(dTdx, 1, 1);
1023 ADReal p_ad(1.5e6, dpdx);
1024 ADReal T_ad(450.0, dTdx);
1025 // value
1026 ABS_TEST(_tab_pT_from_fp_idg->v_from_p_T(p_ad, T_ad).value(),
1027 _idg_fp->v_from_p_T(p_ad, T_ad).value(),
1028 tol);
1029 ABS_TEST(_tab_pT_from_fp_idg->rho_from_p_T(p_ad, T_ad).value(),
1030 _idg_fp->rho_from_p_T(p_ad, T_ad).value(),
1031 tol);
1032 ABS_TEST(_tab_pT_from_fp_idg->e_from_p_T(p_ad, T_ad).value(),
1033 _idg_fp->e_from_p_T(p_ad, T_ad).value(),
1034 tol);
1035 ABS_TEST(_tab_pT_from_fp_idg->cp_from_p_T(p_ad, T_ad).value(),
1036 _idg_fp->cp_from_p_T(p_ad, T_ad).value(),
1037 tol);
1038 // derivatives
1039 ABS_TEST(_tab_pT_from_fp_idg->v_from_p_T(p_ad, T_ad).derivatives()[0],
1040 _idg_fp->v_from_p_T(p_ad, T_ad).derivatives()[0],
1041 tol);
1042 ABS_TEST(_tab_pT_from_fp_idg->rho_from_p_T(p_ad, T_ad).derivatives()[0],
1043 _idg_fp->rho_from_p_T(p_ad, T_ad).derivatives()[0],
1044 tol);
1045 ABS_TEST(_tab_pT_from_fp_idg->e_from_p_T(p_ad, T_ad).derivatives()[0],
1046 _idg_fp->e_from_p_T(p_ad, T_ad).derivatives()[0],
1047 tol);
1048 ABS_TEST(_tab_pT_from_fp_idg->cp_from_p_T(p_ad, T_ad).derivatives()[0],
1049 _idg_fp->cp_from_p_T(p_ad, T_ad).derivatives()[0],
1050 tol);
1051 ABS_TEST(_tab_pT_from_fp_idg->v_from_p_T(p_ad, T_ad).derivatives()[1],
1052 _idg_fp->v_from_p_T(p_ad, T_ad).derivatives()[1],
1053 tol);
1054 ABS_TEST(_tab_pT_from_fp_idg->rho_from_p_T(p_ad, T_ad).derivatives()[1],
1055 _idg_fp->rho_from_p_T(p_ad, T_ad).derivatives()[1],
1056 tol);
1057 ABS_TEST(_tab_pT_from_fp_idg->e_from_p_T(p_ad, T_ad).derivatives()[1],
1058 _idg_fp->e_from_p_T(p_ad, T_ad).derivatives()[1],
1059 tol);
1060 ABS_TEST(_tab_pT_from_fp_idg->cp_from_p_T(p_ad, T_ad).derivatives()[1],
1061 _idg_fp->cp_from_p_T(p_ad, T_ad).derivatives()[1],
1062 tol);
1063}

◆ TEST_F() [12/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
passthroughVE   
)

Definition at line 1067 of file TabulatedBicubicFluidPropertiesTest.C.

1068{
1069 Real p = 1.5e6;
1070 Real T = 450.0;
1071 Real v = 1. / _idg_fp->rho_from_p_T(p, T);
1072 Real e = _idg_fp->e_from_p_T(p, T);
1073 const Real tol = REL_TOL_CONSISTENCY;
1074
1075 // need to generate (v,e) bounds
1076 const_cast<TabulatedBicubicFluidProperties *>(_tab_ve_from_fp)->initialSetup();
1077 // we use this tabulation based on idg as too many (v,e) routines are missing for CO2
1078
1079 // As the flags for interpolation in TabulatedBicubicFluidProperties default to false,
1080 // properties will be passed through to the given fluid properties object
1081 ABS_TEST(_tab_ve_from_fp->T_from_v_e(v, e), _idg_fp->T_from_v_e(v, e), tol);
1082 ABS_TEST(_tab_ve_from_fp->p_from_v_e(v, e), _idg_fp->p_from_v_e(v, e), 3 * tol);
1083 ABS_TEST(_tab_ve_from_fp->h_from_v_e(v, e), _idg_fp->h_from_v_e(v, e), tol);
1084 ABS_TEST(_tab_ve_from_fp->mu_from_v_e(v, e), _idg_fp->mu_from_v_e(v, e), tol);
1085 ABS_TEST(_tab_ve_from_fp->k_from_v_e(v, e), _idg_fp->k_from_v_e(v, e), tol);
1086 ABS_TEST(_tab_ve_from_fp->cp_from_v_e(v, e), _idg_fp->cp_from_v_e(v, e), tol);
1087 ABS_TEST(_tab_ve_from_fp->cv_from_v_e(v, e), _idg_fp->cv_from_v_e(v, e), tol);
1088 ABS_TEST(_tab_ve_from_fp->s_from_v_e(v, e), _idg_fp->s_from_v_e(v, e), 30 * tol);
1089
1090 // passthrough with derivatives
1091 {
1092 Real pert = 1e-7;
1093 Real deriv1, deriv2;
1094 // temperature
1095 Real T1;
1096 _tab_ve_from_fp->T_from_v_e(v, e, T1, deriv1, deriv2);
1097 Real T_0 = _tab_ve_from_fp->T_from_v_e(v, e);
1098 Real T_1 = _tab_ve_from_fp->T_from_v_e(v * (1 + pert), e);
1099 Real T_2 = _tab_ve_from_fp->T_from_v_e(v, e * (1 + pert));
1100 REL_TEST(deriv1, (T_1 - T_0) / (v * pert), 0.001);
1101 REL_TEST(deriv2, (T_2 - T_0) / (e * pert), 0.001);
1102
1103 // pressure
1104 Real p1;
1105 _tab_ve_from_fp->p_from_v_e(v, e, p1, deriv1, deriv2);
1106 Real p_0 = _tab_ve_from_fp->p_from_v_e(v, e);
1107 Real p_1 = _tab_ve_from_fp->p_from_v_e(v * (1 + pert), e);
1108 Real p_2 = _tab_ve_from_fp->p_from_v_e(v, e * (1 + pert));
1109 REL_TEST(deriv1, (p_1 - p_0) / (v * pert), 0.001);
1110 REL_TEST(deriv2, (p_2 - p_0) / (e * pert), 0.001);
1111 }
1112}

◆ TEST_F() [13/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
unequalTemperatures   
)

Definition at line 35 of file TabulatedBicubicFluidPropertiesTest.C.

36{
37 try
38 {
39 const_cast<TabulatedBicubicFluidProperties *>(_unequal_fp)->initialSetup();
40 FAIL();
41 }
42 catch (const std::exception & err)
43 {
44 std::size_t pos = std::string(err.what())
45 .find("temperature values for pressure 2e+06 are not "
46 "identical to values for 1e+06");
47 ASSERT_TRUE(pos != std::string::npos);
48 }
49}

◆ TEST_F() [14/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
unknownColumn   
)

Definition at line 72 of file TabulatedBicubicFluidPropertiesTest.C.

73{
74 try
75 {
76 const_cast<TabulatedBicubicFluidProperties *>(_unknown_col_fp)->initialSetup();
77 FAIL();
78 }
79 catch (const std::exception & err)
80 {
81 std::size_t pos = std::string(err.what())
82 .find("data/csv/unknown_fluid_props.csv tabulation file is not one of "
83 "the properties that TabulatedFluidProperties understands");
84 ASSERT_TRUE(pos != std::string::npos);
85 }
86}

◆ TEST_F() [15/15]

TEST_F ( TabulatedBicubicFluidPropertiesTest  ,
unorderedData   
)

Definition at line 17 of file TabulatedBicubicFluidPropertiesTest.C.

18{
19 try
20 {
21 // Must cast away const to call initialSetup(), where the file is
22 // checked for consistency
23 const_cast<TabulatedBicubicFluidProperties *>(_unordered_fp)->initialSetup();
24 FAIL();
25 }
26 catch (const std::exception & err)
27 {
28 std::size_t pos = std::string(err.what())
29 .find("The column data for temperature is not monotonically increasing");
30 ASSERT_TRUE(pos != std::string::npos);
31 }
32}
Generated on Mon Aug 24 2026 19:11:03 for https://mooseframework.inl.gov by doxygen 1.9.8