My Project
BrineCo2Pvt.hpp
Go to the documentation of this file.
1 // -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 // vi: set et ts=4 sw=4 sts=4:
3 /*
4  This file is part of the Open Porous Media project (OPM).
5 
6  OPM is free software: you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation, either version 2 of the License, or
9  (at your option) any later version.
10 
11  OPM is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with OPM. If not, see <http://www.gnu.org/licenses/>.
18 
19  Consult the COPYING file in the top-level source directory of this
20  module for the precise wording of the license and the list of
21  copyright holders.
22 */
27 #ifndef OPM_BRINE_CO2_PVT_HPP
28 #define OPM_BRINE_CO2_PVT_HPP
29 
31 
40 #include <opm/material/components/co2tables.inc>
41 
42 
43 #if HAVE_ECL_INPUT
44 #include <opm/input/eclipse/EclipseState/EclipseState.hpp>
45 #include <opm/input/eclipse/Schedule/Schedule.hpp>
46 #include <opm/input/eclipse/EclipseState/Tables/TableManager.hpp>
47 #endif
48 
49 #include <vector>
50 
51 namespace Opm {
56 template <class Scalar>
58 {
59  typedef std::vector<std::pair<Scalar, Scalar> > SamplingPoints;
60  static const bool extrapolate = true;
61  //typedef H2O<Scalar> H2O_IAPWS;
62  //typedef Brine<Scalar, H2O_IAPWS> Brine_IAPWS;
63  //typedef TabulatedComponent<Scalar, H2O_IAPWS> H2O_Tabulated;
64  //typedef TabulatedComponent<Scalar, Brine_IAPWS> Brine_Tabulated;
65 
66  //typedef H2O_Tabulated H2O;
67  //typedef Brine_Tabulated Brine;
68 
69 
70 public:
72  typedef ::Opm::Brine<Scalar, H2O> Brine;
73  typedef ::Opm::CO2<Scalar, CO2Tables> CO2;
74 
76 
79 
80  explicit BrineCo2Pvt() = default;
81  BrineCo2Pvt(const std::vector<Scalar>& brineReferenceDensity,
82  const std::vector<Scalar>& co2ReferenceDensity,
83  const std::vector<Scalar>& salinity)
84  : brineReferenceDensity_(brineReferenceDensity),
85  co2ReferenceDensity_(co2ReferenceDensity),
86  salinity_(salinity)
87  {
88  Brine::salinity = salinity[0];
89  }
90 
91  BrineCo2Pvt(const std::vector<Scalar>& salinity,
92  Scalar T_ref = 288.71, //(273.15 + 15.56)
93  Scalar P_ref = 101325)
94  : salinity_(salinity)
95  {
96  int num_regions = salinity_.size();
97  co2ReferenceDensity_.resize(num_regions);
98  brineReferenceDensity_.resize(num_regions);
99  for (int i = 0; i < num_regions; ++i) {
100  co2ReferenceDensity_[i] = CO2::gasDensity(T_ref, P_ref, true);
101  brineReferenceDensity_[i] = Brine::liquidDensity(T_ref, P_ref, true);
102  }
103  Brine::salinity = salinity[0];
104  }
105 #if HAVE_ECL_INPUT
110  void initFromState(const EclipseState& eclState, const Schedule&)
111  {
112  if( !eclState.getTableManager().getDensityTable().empty()) {
113  std::cerr << "WARNING: CO2STOR is enabled but DENSITY is in the deck. \n" <<
114  "The surface density is computed based on CO2-BRINE PVT at standard conditions (STCOND) and DENSITY is ignored " << std::endl;
115  }
116 
117  if( eclState.getTableManager().hasTables("PVDO") || !eclState.getTableManager().getPvtoTables().empty()) {
118  std::cerr << "WARNING: CO2STOR is enabled but PVDO or PVTO is in the deck. \n" <<
119  "BRINE PVT properties are computed based on the Hu et al. pvt model and PVDO/PVTO input is ignored. " << std::endl;
120  }
121 
122  // We only supported single pvt region for the co2-brine module
123  size_t numRegions = 1;
124  setNumRegions(numRegions);
125  size_t regionIdx = 0;
126  // Currently we only support constant salinity
127  const Scalar molality = eclState.getTableManager().salinity(); // mol/kg
128  const Scalar MmNaCl = 58e-3; // molar mass of NaCl [kg/mol]
129  // convert to mass fraction
130  Brine::salinity = 1 / ( 1 + 1 / (molality*MmNaCl)); //
131  salinity_[regionIdx] = Brine::salinity;
132  // set the surface conditions using the STCOND keyword
133  Scalar T_ref = eclState.getTableManager().stCond().temperature;
134  Scalar P_ref = eclState.getTableManager().stCond().pressure;
135 
136  brineReferenceDensity_[regionIdx] = Brine::liquidDensity(T_ref, P_ref, extrapolate);
137  co2ReferenceDensity_[regionIdx] = CO2::gasDensity(T_ref, P_ref, extrapolate);
138  }
139 #endif
140 
141  void setNumRegions(size_t numRegions)
142  {
143  brineReferenceDensity_.resize(numRegions);
144  co2ReferenceDensity_.resize(numRegions);
145  salinity_.resize(numRegions);
146  }
147 
148 
152  void setReferenceDensities(unsigned regionIdx,
153  Scalar rhoRefBrine,
154  Scalar rhoRefCO2,
155  Scalar /*rhoRefWater*/)
156  {
157  brineReferenceDensity_[regionIdx] = rhoRefBrine;
158  co2ReferenceDensity_[regionIdx] = rhoRefCO2;
159  }
160 
161 
165  void initEnd()
166  {
167 
168  }
169 
173  unsigned numRegions() const
174  { return brineReferenceDensity_.size(); }
175 
179  template <class Evaluation>
180  Evaluation internalEnergy(unsigned regionIdx,
181  const Evaluation& temperature,
182  const Evaluation& pressure,
183  const Evaluation& Rs) const
184  {
185 
186  const Evaluation xlCO2 = convertXoGToxoG_(convertRsToXoG_(Rs,regionIdx));
187  return (liquidEnthalpyBrineCO2_(temperature,
188  pressure,
189  salinity_[regionIdx],
190  xlCO2)
191  - pressure / density_(regionIdx, temperature, pressure, Rs));
192  }
193 
197  template <class Evaluation>
198  Evaluation viscosity(unsigned regionIdx,
199  const Evaluation& temperature,
200  const Evaluation& pressure,
201  const Evaluation& /*Rs*/) const
202  {
203  //TODO: The viscosity does not yet depend on the composition
204  return saturatedViscosity(regionIdx, temperature, pressure);
205  }
206 
210  template <class Evaluation>
211  Evaluation saturatedViscosity(unsigned /*regionIdx*/,
212  const Evaluation& temperature,
213  const Evaluation& pressure) const
214  {
215  return Brine::liquidViscosity(temperature, pressure);
216  }
217 
221  template <class Evaluation>
222  Evaluation inverseFormationVolumeFactor(unsigned regionIdx,
223  const Evaluation& temperature,
224  const Evaluation& pressure,
225  const Evaluation& Rs) const
226  {
227  return (1.0 - convertRsToXoG_(Rs,regionIdx)) * density_(regionIdx, temperature, pressure, Rs)/brineReferenceDensity_[regionIdx];
228  }
229 
233  template <class Evaluation>
234  Evaluation saturatedInverseFormationVolumeFactor(unsigned regionIdx,
235  const Evaluation& temperature,
236  const Evaluation& pressure) const
237  {
238  Evaluation rsSat = rsSat_(regionIdx, temperature, pressure);
239  return (1.0 - convertRsToXoG_(rsSat,regionIdx)) * density_(regionIdx, temperature, pressure, rsSat)/brineReferenceDensity_[regionIdx];
240  }
241 
248  template <class Evaluation>
249  Evaluation saturationPressure(unsigned /*regionIdx*/,
250  const Evaluation& /*temperature*/,
251  const Evaluation& /*Rs*/) const
252  {
253  throw std::runtime_error("Requested the saturation pressure for the brine-co2 pvt module. Not yet implemented.");
254  }
255 
259  template <class Evaluation>
260  Evaluation saturatedGasDissolutionFactor(unsigned regionIdx,
261  const Evaluation& temperature,
262  const Evaluation& pressure,
263  const Evaluation& /*oilSaturation*/,
264  const Evaluation& /*maxOilSaturation*/) const
265  {
266  //TODO support VAPPARS
267  return rsSat_(regionIdx, temperature, pressure);
268  }
269 
273  template <class Evaluation>
274  Evaluation saturatedGasDissolutionFactor(unsigned regionIdx,
275  const Evaluation& temperature,
276  const Evaluation& pressure) const
277  {
278  return rsSat_(regionIdx, temperature, pressure);
279  }
280 
281  const Scalar oilReferenceDensity(unsigned regionIdx) const
282  { return brineReferenceDensity_[regionIdx]; }
283 
284  const Scalar gasReferenceDensity(unsigned regionIdx) const
285  { return co2ReferenceDensity_[regionIdx]; }
286 
287  const Scalar salinity(unsigned regionIdx) const
288  { return salinity_[regionIdx]; }
289 
290  bool operator==(const BrineCo2Pvt<Scalar>& data) const
291  {
292  return co2ReferenceDensity_ == data.co2ReferenceDensity_ &&
293  brineReferenceDensity_ == data.brineReferenceDensity_;
294  }
295 
296  template <class Evaluation>
297  Evaluation diffusionCoefficient(const Evaluation& temperature,
298  const Evaluation& pressure,
299  unsigned /*compIdx*/) const
300  {
301  //Diffusion coefficient of CO2 in pure water according to (McLachlan and Danckwerts, 1972)
302  const Evaluation log_D_H20 = -4.1764 + 712.52 / temperature - 2.5907e5 / (temperature*temperature);
303 
304  //Diffusion coefficient of CO2 in the brine phase modified following (Ratcliff and Holdcroft,1963 and Al-Rawajfeh, 2004)
305  const Evaluation& mu_H20 = H2O::liquidViscosity(temperature, pressure, extrapolate); // Water viscosity
306  const Evaluation& mu_Brine = Brine::liquidViscosity(temperature, pressure); // Brine viscosity
307  const Evaluation log_D_Brine = log_D_H20 - 0.87*log10(mu_Brine / mu_H20);
308 
309  return pow(Evaluation(10), log_D_Brine) * 1e-4; // convert from cm2/s to m2/s
310  }
311 
312 private:
313  std::vector<Scalar> brineReferenceDensity_;
314  std::vector<Scalar> co2ReferenceDensity_;
315  std::vector<Scalar> salinity_;
316 
317  template <class LhsEval>
318  LhsEval density_(unsigned regionIdx,
319  const LhsEval& temperature,
320  const LhsEval& pressure,
321  const LhsEval& Rs) const
322  {
323  LhsEval xlCO2 = convertXoGToxoG_(convertRsToXoG_(Rs,regionIdx));
324  LhsEval result = liquidDensity_(temperature,
325  pressure,
326  xlCO2);
327 
328  Valgrind::CheckDefined(result);
329  return result;
330  }
331 
332 
333  template <class LhsEval>
334  LhsEval liquidDensity_(const LhsEval& T,
335  const LhsEval& pl,
336  const LhsEval& xlCO2) const
337  {
338  Valgrind::CheckDefined(T);
339  Valgrind::CheckDefined(pl);
340  Valgrind::CheckDefined(xlCO2);
341 
342  if(!extrapolate && T < 273.15) {
343  std::ostringstream oss;
344  oss << "Liquid density for Brine and CO2 is only "
345  "defined above 273.15K (is "<<T<<"K)";
346  throw NumericalIssue(oss.str());
347  }
348  if(!extrapolate && pl >= 2.5e8) {
349  std::ostringstream oss;
350  oss << "Liquid density for Brine and CO2 is only "
351  "defined below 250MPa (is "<<pl<<"Pa)";
352  throw NumericalIssue(oss.str());
353  }
354 
355  const LhsEval& rho_brine = Brine::liquidDensity(T, pl, extrapolate);
356  const LhsEval& rho_pure = H2O::liquidDensity(T, pl, extrapolate);
357  const LhsEval& rho_lCO2 = liquidDensityWaterCO2_(T, pl, xlCO2);
358  const LhsEval& contribCO2 = rho_lCO2 - rho_pure;
359 
360  return rho_brine + contribCO2;
361  }
362 
363  template <class LhsEval>
364  LhsEval liquidDensityWaterCO2_(const LhsEval& temperature,
365  const LhsEval& pl,
366  const LhsEval& xlCO2) const
367  {
368  Scalar M_CO2 = CO2::molarMass();
369  Scalar M_H2O = H2O::molarMass();
370 
371  const LhsEval& tempC = temperature - 273.15; /* tempC : temperature in °C */
372  const LhsEval& rho_pure = H2O::liquidDensity(temperature, pl, extrapolate);
373  // calculate the mole fraction of CO2 in the liquid. note that xlH2O is available
374  // as a function parameter, but in the case of a pure gas phase the value of M_T
375  // for the virtual liquid phase can become very large
376  const LhsEval xlH2O = 1.0 - xlCO2;
377  const LhsEval& M_T = M_H2O * xlH2O + M_CO2 * xlCO2;
378  const LhsEval& V_phi =
379  (37.51 +
380  tempC*(-9.585e-2 +
381  tempC*(8.74e-4 -
382  tempC*5.044e-7))) / 1.0e6;
383  return 1/ (xlCO2 * V_phi/M_T + M_H2O * xlH2O / (rho_pure * M_T));
384  }
385 
390  template <class LhsEval>
391  LhsEval convertRsToXoG_(const LhsEval& Rs, unsigned regionIdx) const
392  {
393  Scalar rho_oRef = brineReferenceDensity_[regionIdx];
394  Scalar rho_gRef = co2ReferenceDensity_[regionIdx];
395 
396  const LhsEval& rho_oG = Rs*rho_gRef;
397  return rho_oG/(rho_oRef + rho_oG);
398  }
399 
400 
404  template <class LhsEval>
405  LhsEval convertXoGToxoG_(const LhsEval& XoG) const
406  {
407  Scalar M_CO2 = CO2::molarMass();
408  Scalar M_Brine = Brine::molarMass();
409  return XoG*M_Brine / (M_CO2*(1 - XoG) + XoG*M_Brine);
410  }
411 
412 
416  template <class LhsEval>
417  LhsEval convertxoGToXoG(const LhsEval& xoG) const
418  {
419  Scalar M_CO2 = CO2::molarMass();
420  Scalar M_Brine = Brine::molarMass();
421 
422  return xoG*M_CO2 / (xoG*(M_CO2 - M_Brine) + M_Brine);
423  }
424 
425 
430  template <class LhsEval>
431  LhsEval convertXoGToRs(const LhsEval& XoG, unsigned regionIdx) const
432  {
433  Scalar rho_oRef = brineReferenceDensity_[regionIdx];
434  Scalar rho_gRef = co2ReferenceDensity_[regionIdx];
435 
436  return XoG/(1.0 - XoG)*(rho_oRef/rho_gRef);
437  }
438 
439 
440  template <class LhsEval>
441  LhsEval rsSat_(unsigned regionIdx,
442  const LhsEval& temperature,
443  const LhsEval& pressure) const
444  {
445  // calulate the equilibrium composition for the given
446  // temperature and pressure.
447  LhsEval xgH2O;
448  LhsEval xlCO2;
450  pressure,
451  salinity_[regionIdx],
452  /*knownPhaseIdx=*/-1,
453  xlCO2,
454  xgH2O,
455  extrapolate);
456 
457  // normalize the phase compositions
458  xlCO2 = max(0.0, min(1.0, xlCO2));
459 
460  return convertXoGToRs(convertxoGToXoG(xlCO2), regionIdx);
461  }
462 
463  template <class LhsEval>
464  static LhsEval liquidEnthalpyBrineCO2_(const LhsEval& T,
465  const LhsEval& p,
466  Scalar S, // salinity
467  const LhsEval& X_CO2_w)
468  {
469  /* X_CO2_w : mass fraction of CO2 in brine */
470 
471  /* same function as enthalpy_brine, only extended by CO2 content */
472 
473  /*Numerical coefficents from PALLISER*/
474  static Scalar f[] = {
475  2.63500E-1, 7.48368E-6, 1.44611E-6, -3.80860E-10
476  };
477 
478  /*Numerical coefficents from MICHAELIDES for the enthalpy of brine*/
479  static Scalar a[4][3] = {
480  { 9633.6, -4080.0, +286.49 },
481  { +166.58, +68.577, -4.6856 },
482  { -0.90963, -0.36524, +0.249667E-1 },
483  { +0.17965E-2, +0.71924E-3, -0.4900E-4 }
484  };
485 
486  LhsEval theta, h_NaCl;
487  LhsEval h_ls1, d_h;
488  LhsEval delta_h;
489  LhsEval delta_hCO2, hg, hw;
490 
491  theta = T - 273.15;
492 
493  // Regularization
494  Scalar scalarTheta = scalarValue(theta);
495  Scalar S_lSAT = f[0] + scalarTheta*(f[1] + scalarTheta*(f[2] + scalarTheta*f[3]));
496  if (S > S_lSAT)
497  S = S_lSAT;
498 
499  hw = H2O::liquidEnthalpy(T, p) /1E3; /* kJ/kg */
500 
501  /*DAUBERT and DANNER*/
502  /*U=*/h_NaCl = (3.6710E4*T + 0.5*(6.2770E1)*T*T - ((6.6670E-2)/3)*T*T*T
503  +((2.8000E-5)/4)*(T*T*T*T))/(58.44E3)- 2.045698e+02; /* kJ/kg */
504 
505  Scalar m = 1E3/58.44 * S/(1-S);
506  int i = 0;
507  int j = 0;
508  d_h = 0;
509 
510  for (i = 0; i<=3; i++) {
511  for (j=0; j<=2; j++) {
512  d_h = d_h + a[i][j] * pow(theta, static_cast<Scalar>(i)) * std::pow(m, j);
513  }
514  }
515  /* heat of dissolution for halite according to Michaelides 1971 */
516  delta_h = (4.184/(1E3 + (58.44 * m)))*d_h;
517 
518  /* Enthalpy of brine without CO2 */
519  h_ls1 =(1-S)*hw + S*h_NaCl + S*delta_h; /* kJ/kg */
520 
521  /* heat of dissolution for CO2 according to Fig. 6 in Duan and Sun 2003. (kJ/kg)
522  In the relevant temperature ranges CO2 dissolution is
523  exothermal */
524  delta_hCO2 = (-57.4375 + T * 0.1325) * 1000/44;
525 
526  /* enthalpy contribution of CO2 (kJ/kg) */
527  hg = CO2::gasEnthalpy(T, p, extrapolate)/1E3 + delta_hCO2;
528 
529  /* Enthalpy of brine with dissolved CO2 */
530  return (h_ls1 - X_CO2_w*hw + hg*X_CO2_w)*1E3; /*J/kg*/
531  }
532 
533 };
534 
535 } // namespace Opm
536 
537 #endif
A class for the brine fluid properties.
Binary coefficients for brine and CO2.
A class for the CO2 fluid properties.
A central place for various physical constants occuring in some equations.
Binary coefficients for water and CO2.
A simple version of pure water with density from Hu et al.
Implements a linearly interpolated scalar function that depends on one variable.
A generic class which tabulates all thermodynamic properties of a given component.
Implements a scalar function that depends on two variables and which is sampled on an uniform X-Y gri...
Binary coefficients for brine and CO2.
Definition: Brine_CO2.hpp:41
static void calculateMoleFractions(const Evaluation &temperature, const Evaluation &pg, Scalar salinity, const int knownPhaseIdx, Evaluation &xlCO2, Evaluation &ygH2O, bool extrapolate=false)
Returns the mol (!) fraction of CO2 in the liquid phase and the mol_ (!) fraction of H2O in the gas p...
Definition: Brine_CO2.hpp:96
This class represents the Pressure-Volume-Temperature relations of the liquid phase for a CO2-Brine s...
Definition: BrineCo2Pvt.hpp:58
Evaluation internalEnergy(unsigned regionIdx, const Evaluation &temperature, const Evaluation &pressure, const Evaluation &Rs) const
Returns the specific enthalpy [J/kg] of gas given a set of parameters.
Definition: BrineCo2Pvt.hpp:180
Evaluation saturatedGasDissolutionFactor(unsigned regionIdx, const Evaluation &temperature, const Evaluation &pressure, const Evaluation &, const Evaluation &) const
Returns the gas dissoluiton factor [m^3/m^3] of the liquid phase.
Definition: BrineCo2Pvt.hpp:260
Evaluation inverseFormationVolumeFactor(unsigned regionIdx, const Evaluation &temperature, const Evaluation &pressure, const Evaluation &Rs) const
Returns the formation volume factor [-] of the fluid phase.
Definition: BrineCo2Pvt.hpp:222
unsigned numRegions() const
Return the number of PVT regions which are considered by this PVT-object.
Definition: BrineCo2Pvt.hpp:173
Evaluation saturationPressure(unsigned, const Evaluation &, const Evaluation &) const
Returns the saturation pressure of the brine phase [Pa] depending on its mass fraction of the gas com...
Definition: BrineCo2Pvt.hpp:249
void initEnd()
Finish initializing the oil phase PVT properties.
Definition: BrineCo2Pvt.hpp:165
Evaluation saturatedInverseFormationVolumeFactor(unsigned regionIdx, const Evaluation &temperature, const Evaluation &pressure) const
Returns the formation volume factor [-] of brine saturated with CO2 at a given pressure.
Definition: BrineCo2Pvt.hpp:234
void setReferenceDensities(unsigned regionIdx, Scalar rhoRefBrine, Scalar rhoRefCO2, Scalar)
Initialize the reference densities of all fluids for a given PVT region.
Definition: BrineCo2Pvt.hpp:152
BinaryCoeff::Brine_CO2< Scalar, H2O, CO2 > BinaryCoeffBrineCO2
The binary coefficients for brine and CO2 used by this fluid system.
Definition: BrineCo2Pvt.hpp:78
Evaluation viscosity(unsigned regionIdx, const Evaluation &temperature, const Evaluation &pressure, const Evaluation &) const
Returns the dynamic viscosity [Pa s] of the fluid phase given a set of parameters.
Definition: BrineCo2Pvt.hpp:198
Evaluation saturatedGasDissolutionFactor(unsigned regionIdx, const Evaluation &temperature, const Evaluation &pressure) const
Returns thegas dissoluiton factor [m^3/m^3] of the liquid phase.
Definition: BrineCo2Pvt.hpp:274
Evaluation saturatedViscosity(unsigned, const Evaluation &temperature, const Evaluation &pressure) const
Returns the dynamic viscosity [Pa s] of oil saturated gas at given pressure.
Definition: BrineCo2Pvt.hpp:211
A class for the brine fluid properties.
Definition: Brine.hpp:46
static Scalar molarMass()
The molar mass in of the component.
Definition: Brine.hpp:80
static Evaluation liquidDensity(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate=false)
The density of the liquid component at a given pressure in and temperature in .
Definition: Brine.hpp:250
static Evaluation liquidViscosity(const Evaluation &temperature, const Evaluation &)
The dynamic viscosity of pure water.
Definition: Brine.hpp:327
static Scalar salinity
The mass fraction of salt assumed to be in the brine.
Definition: Brine.hpp:49
A class for the CO2 fluid properties.
Definition: CO2.hpp:53
static Scalar molarMass()
The mass in [kg] of one mole of CO2.
Definition: CO2.hpp:66
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate=false)
Specific enthalpy of gaseous CO2 [J/kg].
Definition: CO2.hpp:164
static Evaluation gasDensity(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate=false)
The density of CO2 at a given pressure and temperature [kg/m^3].
Definition: CO2.hpp:189
A simple version of pure water with density from Hu et al.
Definition: SimpleHuDuanH2O.hpp:70
static Evaluation liquidEnthalpy(const Evaluation &temperature, const Evaluation &)
Specific enthalpy of liquid water .
Definition: SimpleHuDuanH2O.hpp:198
static Evaluation liquidViscosity(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate)
The dynamic viscosity of pure water.
Definition: SimpleHuDuanH2O.hpp:350
static Evaluation liquidDensity(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate)
The density of pure water at a given pressure and temperature .
Definition: SimpleHuDuanH2O.hpp:309
static Scalar molarMass()
The molar mass in of water.
Definition: SimpleHuDuanH2O.hpp:104
Implements a linearly interpolated scalar function that depends on one variable.
Definition: Tabulated1DFunction.hpp:47