www.mooseframework.org
SinglePhaseFluidProperties.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
11 
14 {
16  params.set<std::string>("fp_type") = "single-phase-fp";
17 
18  // Variable set conversion parameters
19  params.addRangeCheckedParam<Real>(
20  "tolerance", 1e-8, "tolerance > 0", "Tolerance for 2D Newton variable set conversion");
21  params.addRangeCheckedParam<Real>(
22  "T_initial_guess",
23  400,
24  "T_initial_guess > 0",
25  "Temperature initial guess for Newton Method variable set conversion");
26  params.addRangeCheckedParam<Real>(
27  "p_initial_guess",
28  2e5,
29  "p_initial_guess > 0",
30  "Pressure initial guess for Newton Method variable set conversion");
31  params.addParamNamesToGroup("tolerance T_initial_guess p_initial_guess",
32  "Variable set conversions Newton solve");
33 
34  return params;
35 }
36 
38  : FluidProperties(parameters),
39  // downstream apps are creating fluid properties without their parameters, hence the workaround
40  _tolerance(isParamValid("tolerance") ? getParam<Real>("tolerance") : 1e-8),
41  _T_initial_guess(isParamValid("T_initial_guess") ? getParam<Real>("T_initial_guess") : 400),
42  _p_initial_guess(isParamValid("p_initial_guess") ? getParam<Real>("p_initial_guess") : 2e5)
43 {
44 }
45 
47 
48 #pragma GCC diagnostic push
49 #pragma GCC diagnostic ignored "-Woverloaded-virtual"
50 
51 Real
52 SinglePhaseFluidProperties::s_from_p_T(const Real pressure, const Real temperature) const
53 {
54  Real v, e;
56  return s_from_v_e(v, e);
57 }
58 
59 void
60 SinglePhaseFluidProperties::s_from_p_T(
61  const Real pressure, const Real temperature, Real & s, Real & ds_dp, Real & ds_dT) const
62 {
63  Real v, e, dv_dp, dv_dT, de_dp, de_dT;
64  v_e_from_p_T(pressure, temperature, v, dv_dp, dv_dT, e, de_dp, de_dT);
65 
66  Real ds_dv, ds_de;
67  s_from_v_e(v, e, s, ds_dv, ds_de);
68  ds_dp = ds_dv * dv_dp + ds_de * de_dp;
69  ds_dT = ds_dv * dv_dT + ds_de * de_dT;
70 }
71 
72 Real
73 SinglePhaseFluidProperties::s_from_v_e(const Real v, const Real e) const
74 {
75  const Real p0 = _p_initial_guess;
76  const Real T0 = _T_initial_guess;
77  Real p, T;
78  bool conversion_succeeded = true;
79  p_T_from_v_e(v, e, p0, T0, p, T, conversion_succeeded);
80  const Real s = s_from_p_T(p, T);
81  return s;
82 }
83 
84 void
85 SinglePhaseFluidProperties::s_from_v_e(
86  const Real v, const Real e, Real & s, Real & ds_dv, Real & ds_de) const
87 {
88  const Real p0 = _p_initial_guess;
89  const Real T0 = _T_initial_guess;
90  Real p, T;
91  bool conversion_succeeded = true;
92  p_T_from_v_e(v, e, p0, T0, p, T, conversion_succeeded);
93  s = s_from_p_T(p, T);
94  ds_dv = p / T;
95  ds_de = 1 / T;
96 }
97 
98 Real
99 SinglePhaseFluidProperties::c_from_p_T(Real p, Real T) const
100 {
101  Real v, e;
102  v_e_from_p_T(p, T, v, e);
103  return c_from_v_e(v, e);
104 }
105 
106 void
107 SinglePhaseFluidProperties::c_from_p_T(Real p, Real T, Real & c, Real & dc_dp, Real & dc_dT) const
108 {
109  Real v, e, dv_dp, dv_dT, de_dp, de_dT;
110  v_e_from_p_T(p, T, v, dv_dp, dv_dT, e, de_dp, de_dT);
111 
112  Real dc_dv, dc_de;
113  c_from_v_e(v, e, c, dc_dv, dc_de);
114  dc_dp = dc_dv * dv_dp + dc_de * de_dp;
115  dc_dT = dc_dv * dv_dT + dc_de * de_dT;
116 }
117 
118 Real
119 SinglePhaseFluidProperties::mu_from_p_T(Real p, Real T) const
120 {
121  Real v, e;
122  v_e_from_p_T(p, T, v, e);
123  return mu_from_v_e(v, e);
124 }
125 
126 void
127 SinglePhaseFluidProperties::mu_from_p_T(
128  Real p, Real T, Real & mu, Real & dmu_dp, Real & dmu_dT) const
129 {
130  Real v, e, dv_dp, dv_dT, de_dp, de_dT;
131  v_e_from_p_T(p, T, v, dv_dp, dv_dT, e, de_dp, de_dT);
132 
133  Real dmu_dv, dmu_de;
134  mu_from_v_e(v, e, mu, dmu_dv, dmu_de);
135  dmu_dp = dmu_dv * dv_dp + dmu_de * de_dp;
136  dmu_dT = dmu_dv * dv_dT + dmu_de * de_dT;
137 }
138 
139 Real
140 SinglePhaseFluidProperties::cv_from_p_T(Real p, Real T) const
141 {
142  Real v, e;
143  v_e_from_p_T(p, T, v, e);
144  return cv_from_v_e(v, e);
145 }
146 
147 void
148 SinglePhaseFluidProperties::cv_from_p_T(
149  Real p, Real T, Real & cv, Real & dcv_dp, Real & dcv_dT) const
150 {
151  Real v, e, dv_dp, dv_dT, de_dp, de_dT;
152  v_e_from_p_T(p, T, v, dv_dp, dv_dT, e, de_dp, de_dT);
153 
154  Real dcv_dv, dcv_de;
155  cv_from_v_e(v, e, cv, dcv_dv, dcv_de);
156  dcv_dp = dcv_dv * dv_dp + dcv_de * de_dp;
157  dcv_dT = dcv_dv * dv_dT + dcv_de * de_dT;
158 }
159 
160 Real
161 SinglePhaseFluidProperties::cp_from_p_T(Real p, Real T) const
162 {
163  Real v, e;
164  v_e_from_p_T(p, T, v, e);
165  return cp_from_v_e(v, e);
166 }
167 
168 void
169 SinglePhaseFluidProperties::cp_from_p_T(
170  Real p, Real T, Real & cp, Real & dcp_dp, Real & dcp_dT) const
171 {
172  Real v, e, dv_dp, dv_dT, de_dp, de_dT;
173  v_e_from_p_T(p, T, v, dv_dp, dv_dT, e, de_dp, de_dT);
174 
175  Real dcp_dv, dcp_de;
176  cp_from_v_e(v, e, cp, dcp_dv, dcp_de);
177  dcp_dp = dcp_dv * dv_dp + dcp_de * de_dp;
178  dcp_dT = dcp_dv * dv_dT + dcp_de * de_dT;
179 }
180 
181 Real
182 SinglePhaseFluidProperties::k_from_p_T(Real p, Real T) const
183 {
184  Real v, e;
185  v_e_from_p_T(p, T, v, e);
186  return k_from_v_e(v, e);
187 }
188 
189 void
190 SinglePhaseFluidProperties::k_from_p_T(Real p, Real T, Real & k, Real & dk_dp, Real & dk_dT) const
191 {
192  Real v, e, dv_dp, dv_dT, de_dp, de_dT;
193  v_e_from_p_T(p, T, v, dv_dp, dv_dT, e, de_dp, de_dT);
194 
195  Real dk_dv, dk_de;
196  k_from_v_e(v, e, k, dk_dv, dk_de);
197  dk_dp = dk_dv * dv_dp + dk_de * de_dp;
198  dk_dT = dk_dv * dv_dT + dk_de * de_dT;
199 }
200 
201 Real
202 SinglePhaseFluidProperties::e_from_p_T(Real p, Real T) const
203 {
204  const Real rho = rho_from_p_T(p, T);
205  return e_from_p_rho(p, rho);
206 }
207 
208 void
209 SinglePhaseFluidProperties::e_from_p_T(Real p, Real T, Real & e, Real & de_dp, Real & de_dT) const
210 {
211  // From rho(p,T), compute: drho(p,T)/dp, drho(p,T)/dT
212  Real rho = 0., drho_dp = 0., drho_dT = 0.;
213  rho_from_p_T(p, T, rho, drho_dp, drho_dT);
214 
215  // From e(p, rho), compute: de(p,rho)/dp, de(p,rho)/drho
216  Real depr_dp = 0., depr_drho = 0.;
217  e_from_p_rho(p, rho, e, depr_dp, depr_drho);
218  // Using partial derivative rules, we have:
219  // de(p,T)/dp = de(p,rho)/dp * dp/dp + de(p,rho)/drho * drho(p,T)/dp, (dp/dp == 1)
220  // de(p,T)/dT = de(p,rho)/dp * dp/dT + de(p,rho)/drho * drho(p,T)/dT, (dp/dT == 0)
221  de_dp = depr_dp + depr_drho * drho_dp;
222  de_dT = depr_drho * drho_dT;
223 }
224 
225 Real
226 SinglePhaseFluidProperties::v_from_p_T(Real p, Real T) const
227 {
228  const Real rho = rho_from_p_T(p, T);
229  return 1.0 / rho;
230 }
231 
232 void
233 SinglePhaseFluidProperties::v_from_p_T(Real p, Real T, Real & v, Real & dv_dp, Real & dv_dT) const
234 {
235  Real rho, drho_dp, drho_dT;
236  rho_from_p_T(p, T, rho, drho_dp, drho_dT);
237 
238  v = 1.0 / rho;
239  const Real dv_drho = -1.0 / (rho * rho);
240 
241  dv_dp = dv_drho * drho_dp;
242  dv_dT = dv_drho * drho_dT;
243 }
244 
245 void
246 SinglePhaseFluidProperties::beta_from_p_T(Real, Real, Real &, Real &, Real &) const
247 {
248  mooseError(__PRETTY_FUNCTION__, " is not implemented.");
249 }
250 
251 Real
252 SinglePhaseFluidProperties::beta_from_p_T(Real p, Real T) const
253 {
254  // The volumetric thermal expansion coefficient is defined as
255  // 1/v dv/dT)_p
256  // It is the fractional change rate of volume with respect to temperature change
257  // at constant pressure. Here it is coded as
258  // - 1/rho drho/dT)_p
259  // using chain rule with v = v(rho)
260 
261  Real rho, drho_dp, drho_dT;
262  rho_from_p_T(p, T, rho, drho_dp, drho_dT);
263  return -drho_dT / rho;
264 }
265 
266 Real
268 {
269  mooseError(__PRETTY_FUNCTION__, " not implemented.");
270 }
271 
272 std::string
273 SinglePhaseFluidProperties::fluidName() const
274 {
275  return std::string("");
276 }
277 
278 Real
280 {
281  mooseError(__PRETTY_FUNCTION__, " not implemented.");
282 }
283 
284 Real
286 {
287  mooseError(__PRETTY_FUNCTION__, " not implemented.");
288 }
289 
290 Real
292 {
293  mooseError(__PRETTY_FUNCTION__, " not implemented.");
294 }
295 
296 Real
298 {
299  mooseError(__PRETTY_FUNCTION__, " not implemented.");
300 }
301 
302 Real
304 {
305  mooseError(__PRETTY_FUNCTION__, " not implemented.");
306 }
307 
308 Real
310 {
311  mooseError(__PRETTY_FUNCTION__, " not implemented.");
312 }
313 
314 Real
315 SinglePhaseFluidProperties::gamma_from_v_e(Real v, Real e) const
316 {
317  return cp_from_v_e(v, e) / cv_from_v_e(v, e);
318 }
319 
320 void
321 SinglePhaseFluidProperties::gamma_from_v_e(
322  Real v, Real e, Real & gamma, Real & dgamma_dv, Real & dgamma_de) const
323 {
324  fluidPropError(__PRETTY_FUNCTION__, " derivatives not implemented.");
325 
326  dgamma_dv = 0.0;
327  dgamma_de = 0.0;
328  gamma = gamma_from_v_e(v, e);
329 }
330 
331 Real
332 SinglePhaseFluidProperties::gamma_from_p_T(Real p, Real T) const
333 {
334  return cp_from_p_T(p, T) / cv_from_p_T(p, T);
335 }
336 
337 void
338 SinglePhaseFluidProperties::gamma_from_p_T(
339  Real p, Real T, Real & gamma, Real & dgamma_dp, Real & dgamma_dT) const
340 {
341  fluidPropError(__PRETTY_FUNCTION__, " derivatives not implemented.");
342 
343  dgamma_dp = 0.0;
344  dgamma_dT = 0.0;
345  gamma = gamma_from_p_T(p, T);
346 }
347 
349 {
350  mooseError(__PRETTY_FUNCTION__, " not implemented.");
351 }
352 
353 std::vector<Real>
355 {
356  mooseError(__PRETTY_FUNCTION__, " not implemented.");
357 }
358 
359 void
360 SinglePhaseFluidProperties::vaporPressure(Real T, Real & p, Real & dp_dT) const
361 {
362  fluidPropError(__PRETTY_FUNCTION__, " derivatives not implemented.");
363 
364  dp_dT = 0.0;
365  p = vaporPressure(T);
366 }
367 
368 DualReal
370 {
371  Real p = 0.0;
372  Real temperature = T.value();
373  Real dpdT = 0.0;
374 
375  vaporPressure(temperature, p, dpdT);
376 
377  DualReal result = p;
378  result.derivatives() = T.derivatives() * dpdT;
379 
380  return result;
381 }
382 
384 {
385  mooseError(__PRETTY_FUNCTION__, " not implemented.");
386 }
387 
388 void
389 SinglePhaseFluidProperties::vaporTemperature(Real p, Real & T, Real & dT_dp) const
390 {
391  fluidPropError(__PRETTY_FUNCTION__, " derivatives not implemented.");
392 
393  dT_dp = 0.0;
394  T = vaporTemperature(p);
395 }
396 
397 DualReal
399 {
400  Real T = 0.0;
401  Real pressure = p.value();
402  Real dTdp = 0.0;
403 
404  vaporTemperature(pressure, T, dTdp);
405 
406  DualReal result = T;
407  result.derivatives() = p.derivatives() * dTdp;
408 
409  return result;
410 }
411 
412 void
414  Real T,
415  Real & rho,
416  Real & drho_dp,
417  Real & drho_dT,
418  Real & e,
419  Real & de_dp,
420  Real & de_dT) const
421 {
422  rho_from_p_T(p, T, rho, drho_dp, drho_dT);
423  e_from_p_T(p, T, e, de_dp, de_dT);
424 }
425 
426 void
427 SinglePhaseFluidProperties::rho_mu_from_p_T(Real p, Real T, Real & rho, Real & mu) const
428 {
429  rho = rho_from_p_T(p, T);
430  mu = mu_from_p_T(p, T);
431 }
432 
433 void
435  Real T,
436  Real & rho,
437  Real & drho_dp,
438  Real & drho_dT,
439  Real & mu,
440  Real & dmu_dp,
441  Real & dmu_dT) const
442 {
443  rho_from_p_T(p, T, rho, drho_dp, drho_dT);
444  mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
445 }
446 
447 void
449  const DualReal & T,
450  DualReal & rho,
451  DualReal & mu) const
452 {
453  rho = rho_from_p_T(p, T);
454  mu = mu_from_p_T(p, T);
455 }
456 
458 {
459  mooseError(__PRETTY_FUNCTION__, " not implemented.");
460 }
461 
462 void
464 {
465  mooseError(__PRETTY_FUNCTION__, " not implemented.");
466 }
467 
468 Real
469 SinglePhaseFluidProperties::T_from_p_h(Real p, Real h) const
470 {
471  const Real s = s_from_h_p(h, p);
472  const Real rho = rho_from_p_s(p, s);
473  const Real v = 1. / rho;
474  const Real e = e_from_v_h(v, h);
475  return T_from_v_e(v, e);
476 }
477 
478 Real
479 SinglePhaseFluidProperties::p_from_h_s(Real h, Real s) const
480 {
481  Real p0 = _p_initial_guess;
482  Real T0 = _T_initial_guess;
483  Real p, T;
484  bool conversion_succeeded = true;
485  p_T_from_h_s(h, s, p0, T0, p, T, conversion_succeeded);
486  return p;
487 }
488 
489 void
490 SinglePhaseFluidProperties::p_from_h_s(Real h, Real s, Real & p, Real & dp_dh, Real & dp_ds) const
491 {
492  Real p0 = _p_initial_guess;
493  Real T0 = _T_initial_guess;
494  Real T;
495  bool conversion_succeeded = true;
496  p_T_from_h_s(h, s, p0, T0, p, T, conversion_succeeded);
497  dp_dh = rho_from_p_T(p, T);
498  dp_ds = -T * rho_from_p_T(p, T);
499 }
500 
501 void
502 SinglePhaseFluidProperties::T_from_p_h(Real p, Real h, Real & T, Real & dT_dp, Real & dT_dh) const
503 {
504  Real s, ds_dh, ds_dp;
505  s_from_h_p(h, p, s, ds_dh, ds_dp);
506 
507  Real rho, drho_dp_partial, drho_ds;
508  rho_from_p_s(p, s, rho, drho_dp_partial, drho_ds);
509  const Real drho_dp = drho_dp_partial + drho_ds * ds_dp;
510  const Real drho_dh = drho_ds * ds_dh;
511 
512  const Real v = 1.0 / rho;
513  const Real dv_drho = -1.0 / (rho * rho);
514  const Real dv_dp = dv_drho * drho_dp;
515  const Real dv_dh = dv_drho * drho_dh;
516 
517  Real e, de_dv, de_dh_partial;
518  e_from_v_h(v, h, e, de_dv, de_dh_partial);
519  const Real de_dp = de_dv * dv_dp;
520  const Real de_dh = de_dh_partial + de_dv * dv_dh;
521 
522  Real dT_dv, dT_de;
523  T_from_v_e(v, e, T, dT_dv, dT_de);
524  dT_dp = dT_dv * dv_dp + dT_de * de_dp;
525  dT_dh = dT_dv * dv_dh + dT_de * de_dh;
526 }
527 
528 #pragma GCC diagnostic pop
static const std::string cv
Definition: NS.h:121
virtual Real triplePointTemperature() const
Triple point temperature.
static InputParameters validParams()
static InputParameters validParams()
DualNumber< Real, DNDerivativeType, true > DualReal
T & set(const std::string &name, bool quiet_mode=false)
virtual virtual std Real molarMass() const
Fluid name.
virtual std::vector< Real > henryCoefficients() const
Henry&#39;s law coefficients for dissolution in water.
SinglePhaseFluidProperties(const InputParameters &parameters)
static const std::string temperature
Definition: NS.h:57
void v_e_from_p_T(const CppType &p, const CppType &T, CppType &v, CppType &e) const
void p_T_from_v_e(const CppType &v, const CppType &e, Real p0, Real T0, CppType &p, CppType &T, bool &conversion_succeeded) const
Determines (p,T) from (v,e) using Newton Solve in 2D Useful for conversion between different sets of ...
virtual Real criticalInternalEnergy() const
Critical specific internal energy.
static const std::string cp
Definition: NS.h:120
virtual Real vaporTemperature(Real p) const
Vapor temperature.
virtual Real criticalTemperature() const
Critical temperature.
static const std::string mu
Definition: NS.h:122
virtual void v_e_spndl_from_T(Real T, Real &v, Real &e) const
Specific internal energy from temperature and specific volume.
e e e e s T T T T T rho v v T h
virtual void rho_e_from_p_T(Real p, Real T, Real &rho, Real &drho_dp, Real &drho_dT, Real &e, Real &de_dp, Real &de_dT) const
virtual Real triplePointPressure() const
Triple point pressure.
virtual Real e_spndl_from_v(Real v) const
Specific internal energy from temperature and specific volume.
void p_T_from_h_s(const T &h, const T &s, Real p0, Real T0, T &pressure, T &temperature, bool &conversion_succeeded) const
Determines (p,T) from (h,s) using Newton Solve in 2D Useful for conversion between different sets of ...
virtual void rho_mu_from_p_T(Real p, Real T, Real &rho, Real &mu) const
Combined methods.
virtual Real criticalDensity() const
Critical density.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
static const std::string v
Definition: NS.h:82
static const std::string pressure
Definition: NS.h:56
void mooseError(Args &&... args) const
virtual Real criticalPressure() const
Critical pressure.
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
void fluidPropError(Args... args) const
virtual Real vaporPressure(Real T) const
Vapor pressure.
static const std::string k
Definition: NS.h:124
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)