H2OAirFluidSystem.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_H2O_AIR_SYSTEM_HPP
28 #define OPM_H2O_AIR_SYSTEM_HPP
29 
30 #include "BaseFluidSystem.hpp"
31 #include "NullParameterCache.hpp"
32 
38 #include <opm/common/Valgrind.hpp>
39 
40 #include <opm/common/Exceptions.hpp>
41 #include <opm/common/ErrorMacros.hpp>
42 
43 #include <iostream>
44 #include <cassert>
45 
46 namespace Opm {
47 namespace FluidSystems {
48 
58 template <class Scalar,
59  //class H2Otype = Opm::SimpleH2O<Scalar>,
61  bool useComplexRelations = true>
62 class H2OAir
63  : public BaseFluidSystem<Scalar, H2OAir<Scalar, H2Otype, useComplexRelations> >
64 {
68 
69 public:
70  template <class Evaluation>
71  struct ParameterCache : public Opm::NullParameterCache<Evaluation>
72  {};
73 
75  typedef H2Otype H2O;
78 
80  static const int numPhases = 2;
81 
83  static const int liquidPhaseIdx = 0;
85  static const int gasPhaseIdx = 1;
86 
88  static const char* phaseName(unsigned phaseIdx)
89  {
90  switch (phaseIdx) {
91  case liquidPhaseIdx: return "liquid";
92  case gasPhaseIdx: return "gas";
93  };
94  OPM_THROW(std::logic_error, "Invalid phase index " << phaseIdx);
95  }
96 
98  static bool isLiquid(unsigned phaseIdx)
99  {
100  //assert(0 <= phaseIdx && phaseIdx < numPhases);
101  return phaseIdx != gasPhaseIdx;
102  }
103 
105  static bool isCompressible(unsigned phaseIdx)
106  {
107  //assert(0 <= phaseIdx && phaseIdx < numPhases);
108  return (phaseIdx == gasPhaseIdx)
109  // ideal gases are always compressible
110  ? true
111  :
112  // the water component decides for the liquid phase...
114  }
115 
117  static bool isIdealGas(unsigned phaseIdx)
118  {
119  return
120  (phaseIdx == gasPhaseIdx)
122  : false;
123  }
124 
126  static bool isIdealMixture(unsigned /*phaseIdx*/)
127  {
128  //assert(0 <= phaseIdx && phaseIdx < numPhases);
129  // we assume Henry's and Rault's laws for the water phase and
130  // and no interaction between gas molecules of different
131  // components, so all phases are ideal mixtures!
132  return true;
133  }
134 
135  /****************************************
136  * Component related static parameters
137  ****************************************/
138 
140  static const int numComponents = 2;
141 
143  static const int H2OIdx = 0;
145  static const int AirIdx = 1;
146 
148  static const char* componentName(unsigned compIdx)
149  {
150  switch (compIdx)
151  {
152  case H2OIdx: return H2O::name();
153  case AirIdx: return Air::name();
154  };
155  OPM_THROW(std::logic_error, "Invalid component index " << compIdx);
156  }
157 
159  static Scalar molarMass(unsigned compIdx)
160  {
161  return
162  (compIdx == H2OIdx)
163  ? H2O::molarMass()
164  : (compIdx == AirIdx)
165  ? Air::molarMass()
166  : 1e30;
167  }
168 
169 
175  static Scalar criticalTemperature(unsigned compIdx)
176  {
177  return
178  (compIdx == H2OIdx)
180  : (compIdx == AirIdx)
182  : 1e30;
183  }
184 
190  static Scalar criticalPressure(unsigned compIdx)
191  {
192  return
193  (compIdx == H2OIdx)
195  : (compIdx == AirIdx)
197  : 1e30;
198  }
199 
205  static Scalar acentricFactor(unsigned compIdx)
206  {
207  return
208  (compIdx == H2OIdx)
210  : (compIdx == AirIdx)
211  ? Air::acentricFactor()
212  : 1e30;
213  }
214 
215  /****************************************
216  * thermodynamic relations
217  ****************************************/
218 
225  static void init()
226  {
227  if (H2O::isTabulated)
228  init(/*tempMin=*/273.15,
229  /*tempMax=*/623.15,
230  /*numTemp=*/50,
231  /*pMin=*/-10,
232  /*pMax=*/20e6,
233  /*numP=*/50);
234  }
235 
247  static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp,
248  Scalar pressMin, Scalar pressMax, unsigned nPress)
249  {
250  if (H2O::isTabulated) {
251  H2O::init(tempMin, tempMax, nTemp,
252  pressMin, pressMax, nPress);
253  }
254  }
255 
257  template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
258  static LhsEval density(const FluidState& fluidState,
259  const ParameterCache<ParamCacheEval>& /*paramCache*/,
260  unsigned phaseIdx)
261  {
262  assert(0 <= phaseIdx && phaseIdx < numPhases);
263 
264  const auto& T = Opm::decay<LhsEval>(fluidState.temperature(phaseIdx));
265  LhsEval p;
266  if (isCompressible(phaseIdx))
267  p = Opm::decay<LhsEval>(fluidState.pressure(phaseIdx));
268  else {
269  // random value which will hopefully cause things to blow
270  // up if it is used in a calculation!
271  p = - 1e30;
272  Valgrind::SetUndefined(p);
273  }
274 
275 
276  LhsEval sumMoleFrac = 0;
277  for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
278  sumMoleFrac += Opm::decay<LhsEval>(fluidState.moleFraction(phaseIdx, compIdx));
279 
280  if (phaseIdx == liquidPhaseIdx)
281  {
282  if (!useComplexRelations)
283  // assume pure water
284  return H2O::liquidDensity(T, p);
285  else
286  {
287  // See: Ochs 2008 (2.6)
288  const LhsEval& rholH2O = H2O::liquidDensity(T, p);
289  const LhsEval& clH2O = rholH2O/H2O::molarMass();
290 
291  const auto& xlH2O = Opm::decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, H2OIdx));
292  const auto& xlAir = Opm::decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, AirIdx));
293 
294  return clH2O*(H2O::molarMass()*xlH2O + Air::molarMass()*xlAir)/sumMoleFrac;
295  }
296  }
297  else if (phaseIdx == gasPhaseIdx)
298  {
299  if (!useComplexRelations)
300  // for the gas phase assume an ideal gas
301  return
303  * Opm::decay<LhsEval>(fluidState.averageMolarMass(gasPhaseIdx))
304  / Opm::max(1e-5, sumMoleFrac);
305 
306  LhsEval partialPressureH2O =
307  Opm::decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, H2OIdx))
308  *Opm::decay<LhsEval>(fluidState.pressure(gasPhaseIdx));
309 
310  LhsEval partialPressureAir =
311  Opm::decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, AirIdx))
312  *Opm::decay<LhsEval>(fluidState.pressure(gasPhaseIdx));
313 
314  return H2O::gasDensity(T, partialPressureH2O) + Air::gasDensity(T, partialPressureAir);
315  }
316  OPM_THROW(std::logic_error, "Invalid phase index " << phaseIdx);
317  }
318 
320  template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
321  static LhsEval viscosity(const FluidState& fluidState,
322  const ParameterCache<ParamCacheEval>& /*paramCache*/,
323  unsigned phaseIdx)
324  {
325  assert(0 <= phaseIdx && phaseIdx < numPhases);
326 
327  const auto& T = Opm::decay<LhsEval>(fluidState.temperature(phaseIdx));
328  const auto& p = Opm::decay<LhsEval>(fluidState.pressure(phaseIdx));
329 
330  if (phaseIdx == liquidPhaseIdx)
331  {
332  // assume pure water for the liquid phase
333  // TODO: viscosity of mixture
334  // couldn't find a way to solve the mixture problem
335  return H2O::liquidViscosity(T, p);
336  }
337  else if (phaseIdx == gasPhaseIdx)
338  {
339  if(!useComplexRelations){
340  return Air::gasViscosity(T, p);
341  }
342  else //using a complicated version of this fluid system
343  {
344  /* Wilke method. See:
345  *
346  * See: R. Reid, et al.: The Properties of Gases and Liquids,
347  * 4th edition, McGraw-Hill, 1987, 407-410 or
348  * 5th edition, McGraw-Hill, 2000, p. 9.21/22
349  *
350  */
351 
352  LhsEval muResult = 0;
353  const LhsEval mu[numComponents] = {
355  Air::gasViscosity(T, p)
356  };
357 
358  // molar masses
359  const Scalar M[numComponents] = {
360  H2O::molarMass(),
362  };
363 
364  for (unsigned i = 0; i < numComponents; ++i) {
365  LhsEval divisor = 0;
366  for (unsigned j = 0; j < numComponents; ++j) {
367  LhsEval phiIJ =
368  1 +
369  Opm::sqrt(mu[i]/mu[j]) * // 1 + (mu[i]/mu[j]^1/2
370  std::pow(M[j]/M[i], 1./4.0); // (M[i]/M[j])^1/4
371 
372  phiIJ *= phiIJ;
373  phiIJ /= std::sqrt(8*(1 + M[i]/M[j]));
374  divisor += Opm::decay<LhsEval>(fluidState.moleFraction(phaseIdx, j))*phiIJ;
375  }
376  const auto& xAlphaI = Opm::decay<LhsEval>(fluidState.moleFraction(phaseIdx, i));
377  muResult += xAlphaI*mu[i]/divisor;
378  }
379  return muResult;
380  }
381  }
382  OPM_THROW(std::logic_error, "Invalid phase index " << phaseIdx);
383  }
384 
386  template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
387  static LhsEval fugacityCoefficient(const FluidState& fluidState,
388  const ParameterCache<ParamCacheEval>& /*paramCache*/,
389  unsigned phaseIdx,
390  unsigned compIdx)
391  {
392  assert(0 <= phaseIdx && phaseIdx < numPhases);
393  assert(0 <= compIdx && compIdx < numComponents);
394 
395  const auto& T = Opm::decay<LhsEval>(fluidState.temperature(phaseIdx));
396  const auto& p = Opm::decay<LhsEval>(fluidState.pressure(phaseIdx));
397 
398  if (phaseIdx == liquidPhaseIdx) {
399  if (compIdx == H2OIdx)
400  return H2O::vaporPressure(T)/p;
402  }
403 
404  // for the gas phase, assume an ideal gas when it comes to
405  // fugacity (-> fugacity == partial pressure)
406  return 1.0;
407  }
408 
410  template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
411  static LhsEval binaryDiffusionCoefficient(const FluidState& fluidState,
412  const ParameterCache<ParamCacheEval>& /*paramCache*/,
413  unsigned phaseIdx,
414  unsigned /*compIdx*/)
415  {
416  const auto& T = Opm::decay<LhsEval>(fluidState.temperature(phaseIdx));
417  const auto& p = Opm::decay<LhsEval>(fluidState.pressure(phaseIdx));
418 
419  if (phaseIdx == liquidPhaseIdx)
421 
422  assert(phaseIdx == gasPhaseIdx);
424  }
425 
427  template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
428  static LhsEval enthalpy(const FluidState& fluidState,
429  const ParameterCache<ParamCacheEval>& /*paramCache*/,
430  unsigned phaseIdx)
431  {
432  const auto& T = Opm::decay<LhsEval>(fluidState.temperature(phaseIdx));
433  const auto& p = Opm::decay<LhsEval>(fluidState.pressure(phaseIdx));
434  Valgrind::CheckDefined(T);
435  Valgrind::CheckDefined(p);
436 
437  if (phaseIdx == liquidPhaseIdx)
438  {
439  // TODO: correct way to deal with the solutes???
440  return H2O::liquidEnthalpy(T, p);
441  }
442 
443  else if (phaseIdx == gasPhaseIdx)
444  {
445  LhsEval result = 0.0;
446  result +=
447  H2O::gasEnthalpy(T, p) *
448  Opm::decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, H2OIdx));
449 
450  result +=
451  Air::gasEnthalpy(T, p) *
452  Opm::decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, AirIdx));
453  return result;
454  }
455  OPM_THROW(std::logic_error, "Invalid phase index " << phaseIdx);
456  }
457 
459  template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
460  static LhsEval thermalConductivity(const FluidState& fluidState,
461  const ParameterCache<ParamCacheEval>& /*paramCache*/,
462  unsigned phaseIdx)
463  {
464  assert(0 <= phaseIdx && phaseIdx < numPhases);
465 
466  const LhsEval& temperature =
467  Opm::decay<LhsEval>(fluidState.temperature(phaseIdx));
468  const LhsEval& pressure =
469  Opm::decay<LhsEval>(fluidState.pressure(phaseIdx));
470 
471  if (phaseIdx == liquidPhaseIdx)
472  return H2O::liquidThermalConductivity(temperature, pressure);
473  else { // gas phase
474  const LhsEval& lambdaDryAir = Air::gasThermalConductivity(temperature, pressure);
475 
476  if (useComplexRelations){
477  const LhsEval& xAir =
478  Opm::decay<LhsEval>(fluidState.moleFraction(phaseIdx, AirIdx));
479  const LhsEval& xH2O =
480  Opm::decay<LhsEval>(fluidState.moleFraction(phaseIdx, H2OIdx));
481  LhsEval lambdaAir = xAir*lambdaDryAir;
482 
483  // Assuming Raoult's, Daltons law and ideal gas
484  // in order to obtain the partial density of water in the air phase
485  LhsEval partialPressure = pressure*xH2O;
486 
487  LhsEval lambdaH2O =
488  xH2O*H2O::gasThermalConductivity(temperature, partialPressure);
489  return lambdaAir + lambdaH2O;
490  }
491  else
492  return lambdaDryAir; // conductivity of Nitrogen [W / (m K ) ]
493  }
494  }
495 };
496 
497 } // namespace FluidSystems
498 
499 } // namespace Opm
500 
501 #endif
static bool isIdealGas(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition: H2OAirFluidSystem.hpp:117
static Evaluation liquidDensity(const Evaluation &temperature, const Evaluation &pressure)
The density of pure water in at a given pressure and temperature.
Definition: H2O.hpp:678
static Scalar criticalPressure(unsigned compIdx)
Critical pressure of a component [Pa].
Definition: H2OAirFluidSystem.hpp:190
static bool gasIsIdeal()
Returns true iff the gas phase is assumed to be ideal.
Definition: H2O.hpp:618
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp, Scalar pressMin, Scalar pressMax, unsigned nPress)
Initialize the fluid system&#39;s static parameters using problem specific temperature and pressure range...
Definition: H2OAirFluidSystem.hpp:247
Relations valid for an ideal gas.
static const int numPhases
Number of fluid phases in the fluid system.
Definition: H2OAirFluidSystem.hpp:80
static bool liquidIsCompressible()
Returns true iff the liquid phase is assumed to be compressible.
Definition: H2O.hpp:537
static bool isIdealMixture(unsigned)
Returns true if and only if a fluid phase is assumed to be an ideal mixture.
Definition: H2OAirFluidSystem.hpp:126
static Evaluation gasViscosity(const Evaluation &temperature, const Evaluation &pressure)
The dynamic viscosity of steam.
Definition: H2O.hpp:779
static Evaluation liquidDiffCoeff(const Evaluation &temperature, const Evaluation &)
Lacking better data on water-air diffusion in liquids, we use at the moment the diffusion coefficient...
Definition: H2O_Air.hpp:101
static const int numComponents
Number of chemical species in the fluid system.
Definition: H2OAirFluidSystem.hpp:140
static Scalar criticalPressure()
Returns the critical pressure of .
Definition: Air.hpp:93
static bool isLiquid(unsigned phaseIdx)
Return whether a phase is liquid.
Definition: H2OAirFluidSystem.hpp:98
static void init(Scalar, Scalar, unsigned, Scalar, Scalar, unsigned)
A default routine for initialization, not needed for components and must not be called.
Definition: Component.hpp:62
static const Scalar acentricFactor()
The acentric factor of water.
Definition: H2O.hpp:86
static bool gasIsIdeal()
Returns true iff the gas phase is assumed to be ideal.
Definition: Air.hpp:73
static LhsEval binaryDiffusionCoefficient(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx, unsigned)
Calculate the binary molecular diffusion coefficient for a component in a fluid phase [mol^2 * s / (k...
Definition: H2OAirFluidSystem.hpp:411
static Evaluation gasDensity(const Evaluation &temperature, const Evaluation &pressure)
The density of steam in at a given pressure and temperature.
Definition: H2O.hpp:553
static Evaluation liquidThermalConductivity(const Evaluation &temperature, const Evaluation &pressure)
Thermal conductivity of water (IAPWS) .
Definition: H2O.hpp:831
static Evaluation gasViscosity(const Evaluation &temperature, const Evaluation &)
The dynamic viscosity of at a given pressure and temperature.
Definition: Air.hpp:138
static Evaluation liquidEnthalpy(const Evaluation &temperature, const Evaluation &pressure)
Specific enthalpy of liquid water .
Definition: H2O.hpp:228
Definition: H2OAirFluidSystem.hpp:71
A fluid system with a liquid and a gaseous phase and water and air as components. ...
Definition: H2OAirFluidSystem.hpp:62
static Scalar criticalTemperature()
Returns the critical temperature of .
Definition: Air.hpp:87
Definition: Air_Mesitylene.hpp:33
static Scalar molarMass()
The molar mass in of .
Definition: Air.hpp:81
A parameter cache which does nothing.
A simple class implementing the fluid properties of air.
Definition: Air.hpp:47
static Evaluation henry(const Evaluation &temperature)
Henry coefficent for air in liquid water.
Definition: H2O_Air.hpp:55
Material properties of pure water .
static Evaluation gasDensity(const Evaluation &temperature, const Evaluation &pressure)
The density of at a given pressure and temperature [kg/m^3].
Definition: Air.hpp:103
static LhsEval enthalpy(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Given a phase&#39;s composition, temperature, pressure and density, calculate its specific enthalpy [J/kg...
Definition: H2OAirFluidSystem.hpp:428
static const int liquidPhaseIdx
The index of the liquid phase.
Definition: H2OAirFluidSystem.hpp:83
static Scalar criticalTemperature(unsigned compIdx)
Critical temperature of a component [K].
Definition: H2OAirFluidSystem.hpp:175
static const char * name()
A human readable name for the water.
Definition: H2O.hpp:74
static Evaluation gasThermalConductivity(const Evaluation &, const Evaluation &)
Specific heat conductivity of steam .
Definition: Air.hpp:219
static Scalar acentricFactor(unsigned compIdx)
The acentric factor of a component [].
Definition: H2OAirFluidSystem.hpp:205
static const int gasPhaseIdx
The index of the gas phase.
Definition: H2OAirFluidSystem.hpp:85
static const int H2OIdx
The index of the water component.
Definition: H2OAirFluidSystem.hpp:143
Opm::Air< Scalar > Air
The type of the air component used for this fluid system.
Definition: H2OAirFluidSystem.hpp:77
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &)
Specific enthalpy of liquid water with 273.15 K as basis.
Definition: Air.hpp:182
static Evaluation gasDiffCoeff(const Evaluation &temperature, const Evaluation &pressure)
Binary diffusion coefficent for molecular water and air.
Definition: H2O_Air.hpp:70
Relations valid for an ideal gas.
Definition: IdealGas.hpp:37
static Evaluation liquidViscosity(const Evaluation &temperature, const Evaluation &pressure)
The dynamic viscosity of pure water.
Definition: H2O.hpp:804
static const Scalar criticalTemperature()
Returns the critical temperature of water.
Definition: H2O.hpp:92
A simple class implementing the fluid properties of air.
static Evaluation vaporPressure(Evaluation temperature)
The vapor pressure in of pure water at a given temperature.
Definition: H2O.hpp:132
static const int AirIdx
The index of the air component.
Definition: H2OAirFluidSystem.hpp:145
static bool isCompressible(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be compressible.
Definition: H2OAirFluidSystem.hpp:105
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &pressure)
Specific enthalpy of water steam .
Definition: H2O.hpp:177
A generic class which tabulates all thermodynamic properties of a given component.
The base class for all fluid systems.
Definition: BaseFluidSystem.hpp:43
static Evaluation gasThermalConductivity(const Evaluation &temperature, const Evaluation &pressure)
Thermal conductivity of water (IAPWS) .
Definition: H2O.hpp:851
A generic class which tabulates all thermodynamic properties of a given component.
Definition: TabulatedComponent.hpp:58
static LhsEval fugacityCoefficient(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx, unsigned compIdx)
Calculate the fugacity coefficient [Pa] of an individual component in a fluid phase.
Definition: H2OAirFluidSystem.hpp:387
static const char * name()
A human readable name for the .
Definition: Air.hpp:61
static LhsEval thermalConductivity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Thermal conductivity of a fluid phase [W/(m K)].
Definition: H2OAirFluidSystem.hpp:460
static Evaluation molarDensity(const Evaluation &temperature, const Evaluation &pressure)
The molar density of the gas , depending on pressure and temperature.
Definition: IdealGas.hpp:67
static const char * phaseName(unsigned phaseIdx)
Return the human readable name of a fluid phase.
Definition: H2OAirFluidSystem.hpp:88
static LhsEval viscosity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the dynamic viscosity of a fluid phase [Pa*s].
Definition: H2OAirFluidSystem.hpp:321
A parameter cache which does nothing.
Definition: NullParameterCache.hpp:39
static const Scalar molarMass()
The molar mass in of water.
Definition: H2O.hpp:80
Scalar Scalar
The type used for scalar quantities.
Definition: BaseFluidSystem.hpp:49
static Scalar molarMass(unsigned compIdx)
Return the molar mass of a component in [kg/mol].
Definition: H2OAirFluidSystem.hpp:159
static LhsEval density(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the density [kg/m^3] of a fluid phase.
Definition: H2OAirFluidSystem.hpp:258
static const Scalar criticalPressure()
Returns the critical pressure of water.
Definition: H2O.hpp:98
static const char * componentName(unsigned compIdx)
Return the human readable name of a component.
Definition: H2OAirFluidSystem.hpp:148
Binary coefficients for water and nitrogen.
H2Otype H2O
The type of the water component used for this fluid system.
Definition: H2OAirFluidSystem.hpp:75
The base class for all fluid systems.
static void init()
Initialize the fluid system&#39;s static parameters.
Definition: H2OAirFluidSystem.hpp:225