My Project
Loading...
Searching...
No Matches
BrineCO2FluidSystem.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*/
28#ifndef OPM_BRINE_CO2_SYSTEM_HPP
29#define OPM_BRINE_CO2_SYSTEM_HPP
30
31#include "BaseFluidSystem.hpp"
33
35
37
43
47
48namespace Opm {
49
50// Silence compiler warnings about use of variables
51// that are instantiated in a different compilation unit.
52template<>
53const float CO2<float>::brineSalinity;
54template<>
55const double CO2<double>::brineSalinity;
56
64template <class Scalar>
66 : public BaseFluidSystem<Scalar, BrineCO2FluidSystem<Scalar> >
67{
68 typedef ::Opm::H2O<Scalar> H2O_IAPWS;
69 typedef ::Opm::Brine<Scalar, H2O_IAPWS> Brine_IAPWS;
72
73 typedef H2O_Tabulated H2O;
74
75public:
76 template <class Evaluation>
77 struct ParameterCache : public NullParameterCache<Evaluation>
78 {};
79
83 typedef ::Opm::CO2<Scalar> CO2;
84
87
88 /****************************************
89 * Fluid phase related static parameters
90 ****************************************/
91
93 static const int numPhases = 2;
94
96 static const int liquidPhaseIdx = 0;
98 static const int gasPhaseIdx = 1;
99
103 static const char* phaseName(unsigned phaseIdx)
104 {
105 static const char* name[] = {
106 "liquid",
107 "gas"
108 };
109
110 assert(phaseIdx < numPhases);
111 return name[phaseIdx];
112 }
113
117 static bool isLiquid(unsigned phaseIdx)
118 {
119 assert(phaseIdx < numPhases);
120
121 return phaseIdx != gasPhaseIdx;
122 }
123
127 static bool isIdealGas(unsigned phaseIdx)
128 {
129 assert(phaseIdx < numPhases);
130
131 if (phaseIdx == gasPhaseIdx)
132 return CO2::gasIsIdeal();
133 return false;
134 }
135
139 static bool isIdealMixture([[maybe_unused]] unsigned phaseIdx)
140 {
141 assert(phaseIdx < numPhases);
142
143 return true;
144 }
145
149 static bool isCompressible([[maybe_unused]] unsigned phaseIdx)
150 {
151 assert(phaseIdx < numPhases);
152
153 return true;
154 }
155
156 /****************************************
157 * Component related static parameters
158 ****************************************/
160 static const int numComponents = 2;
161
163 static const int BrineIdx = 0;
165 static const int CO2Idx = 1;
166
170 static const char* componentName(unsigned compIdx)
171 {
172 static const char* name[] = {
173 Brine::name(),
174 CO2::name(),
175 };
176
177 assert(compIdx < numComponents);
178 return name[compIdx];
179 }
180
184 static Scalar molarMass(unsigned compIdx)
185 {
186 assert(compIdx < numComponents);
187 return (compIdx==BrineIdx)
189 : CO2::molarMass();
190 }
191
192 /****************************************
193 * thermodynamic relations
194 ****************************************/
195
199 static void init()
200 {
201 init(/*startTemp=*/273.15, /*endTemp=*/623.15, /*tempSteps=*/50,
202 /*startPressure=*/1e4, /*endPressure=*/40e6, /*pressureSteps=*/50);
203 }
204
216 static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp,
217 Scalar pressMin, Scalar pressMax, unsigned nPress)
218 {
219 if (H2O::isTabulated) {
220 H2O_Tabulated::init(tempMin, tempMax, nTemp,
221 pressMin, pressMax, nPress);
222 }
223
224 // set the salinity of brine to the one used by the CO2 tables
225 Brine_IAPWS::salinity = CO2::brineSalinity;
226
227 if (Brine::isTabulated) {
228 Brine_Tabulated::init(tempMin, tempMax, nTemp,
229 pressMin, pressMax, nPress);
230 }
231 }
232
236 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
237 static LhsEval density(const FluidState& fluidState,
238 const ParameterCache<ParamCacheEval>& /*paramCache*/,
239 unsigned phaseIdx)
240 {
241 assert(phaseIdx < numPhases);
242
243 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
244 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
245
246 if (phaseIdx == liquidPhaseIdx) {
247 // use normalized composition for to calculate the density
248 // (the relations don't seem to take non-normalized
249 // compositions too well...)
250 LhsEval xlBrine = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, BrineIdx))));
251 LhsEval xlCO2 = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, CO2Idx))));
252 LhsEval sumx = xlBrine + xlCO2;
253 xlBrine /= sumx;
254 xlCO2 /= sumx;
255
256 LhsEval result = liquidDensity_(temperature,
257 pressure,
258 xlBrine,
259 xlCO2);
260
261 Valgrind::CheckDefined(result);
262 return result;
263 }
264
265 assert(phaseIdx == gasPhaseIdx);
266
267 // use normalized composition for to calculate the density
268 // (the relations don't seem to take non-normalized
269 // compositions too well...)
270 LhsEval xgBrine = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, BrineIdx))));
271 LhsEval xgCO2 = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, CO2Idx))));
272 LhsEval sumx = xgBrine + xgCO2;
273 xgBrine /= sumx;
274 xgCO2 /= sumx;
275
276 LhsEval result = gasDensity_(temperature,
277 pressure,
278 xgBrine,
279 xgCO2);
280 Valgrind::CheckDefined(result);
281 return result;
282 }
283
287 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
288 static LhsEval viscosity(const FluidState& fluidState,
289 const ParameterCache<ParamCacheEval>& /*paramCache*/,
290 unsigned phaseIdx)
291 {
292 assert(phaseIdx < numPhases);
293
294 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
295 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
296
297 if (phaseIdx == liquidPhaseIdx) {
298 // assume pure brine for the liquid phase. TODO: viscosity
299 // of mixture
300 LhsEval result = Brine::liquidViscosity(temperature, pressure);
301 Valgrind::CheckDefined(result);
302 return result;
303 }
304
305 assert(phaseIdx == gasPhaseIdx);
306 LhsEval result = CO2::gasViscosity(temperature, pressure);
307 Valgrind::CheckDefined(result);
308 return result;
309 }
310
314 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
315 static LhsEval fugacityCoefficient(const FluidState& fluidState,
316 const ParameterCache<ParamCacheEval>& /*paramCache*/,
317 unsigned phaseIdx,
318 unsigned compIdx)
319 {
320 assert(phaseIdx < numPhases);
321 assert(compIdx < numComponents);
322
323 if (phaseIdx == gasPhaseIdx)
324 // use the fugacity coefficients of an ideal gas. the
325 // actual value of the fugacity is not relevant, as long
326 // as the relative fluid compositions are observed,
327 return 1.0;
328
329 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
330 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
331 assert(temperature > 0);
332 assert(pressure > 0);
333
334 // calulate the equilibrium composition for the given
335 // temperature and pressure. TODO: calculateMoleFractions()
336 // could use some cleanup.
337 LhsEval xlH2O, xgH2O;
338 LhsEval xlCO2, xgCO2;
340 pressure,
341 LhsEval(Brine_IAPWS::salinity),
342 /*knownPhaseIdx=*/-1,
343 xlCO2,
344 xgH2O);
345
346 // normalize the phase compositions
347 xlCO2 = max(0.0, min(1.0, xlCO2));
348 xgH2O = max(0.0, min(1.0, xgH2O));
349
350 xlH2O = 1.0 - xlCO2;
351 xgCO2 = 1.0 - xgH2O;
352
353 if (compIdx == BrineIdx) {
354 Scalar phigH2O = 1.0;
355 return phigH2O * xgH2O / xlH2O;
356 }
357 else {
358 assert(compIdx == CO2Idx);
359
360 Scalar phigCO2 = 1.0;
361 return phigCO2 * xgCO2 / xlCO2;
362 };
363 }
364
368 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
369 static LhsEval diffusionCoefficient(const FluidState& fluidState,
370 const ParameterCache<ParamCacheEval>& /*paramCache*/,
371 unsigned phaseIdx,
372 unsigned /*compIdx*/)
373 {
374 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
375 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
376 if (phaseIdx == liquidPhaseIdx)
377 return BinaryCoeffBrineCO2::liquidDiffCoeff(temperature, pressure);
378
379 assert(phaseIdx == gasPhaseIdx);
380 return BinaryCoeffBrineCO2::gasDiffCoeff(temperature, pressure);
381 }
382
386 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
387 static LhsEval enthalpy(const FluidState& fluidState,
388 const ParameterCache<ParamCacheEval>& /*paramCache*/,
389 unsigned phaseIdx)
390 {
391 assert(phaseIdx < numPhases);
392
393 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
394 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
395
396 if (phaseIdx == liquidPhaseIdx) {
397 const LhsEval& XlCO2 = decay<LhsEval>(fluidState.massFraction(phaseIdx, CO2Idx));
398 const LhsEval& result = liquidEnthalpyBrineCO2_(temperature,
399 pressure,
401 XlCO2);
402 Valgrind::CheckDefined(result);
403 return result;
404 }
405 else {
406 const LhsEval& XCO2 = decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, CO2Idx));
407 const LhsEval& XBrine = decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, BrineIdx));
408
409 LhsEval result = 0;
410 result += XBrine * Brine::gasEnthalpy(temperature, pressure);
411 result += XCO2 * CO2::gasEnthalpy(temperature, pressure);
412 Valgrind::CheckDefined(result);
413 return result;
414 }
415 }
416
420 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
421 static LhsEval thermalConductivity(const FluidState& /*fluidState*/,
422 const ParameterCache<ParamCacheEval>& /*paramCache*/,
423 unsigned phaseIdx)
424 {
425 // TODO way too simple!
426 if (phaseIdx == liquidPhaseIdx)
427 return 0.6; // conductivity of water[W / (m K ) ]
428
429 // gas phase
430 return 0.025; // conductivity of air [W / (m K ) ]
431 }
432
445 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
446 static LhsEval heatCapacity(const FluidState& fluidState,
447 const ParameterCache<ParamCacheEval>& /*paramCache*/,
448 unsigned phaseIdx)
449 {
450 assert(phaseIdx < numPhases);
451
452 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
453 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
454
455 if(phaseIdx == liquidPhaseIdx)
456 return H2O::liquidHeatCapacity(temperature, pressure);
457 else
458 return CO2::gasHeatCapacity(temperature, pressure);
459 }
460
461private:
462 template <class LhsEval>
463 static LhsEval gasDensity_(const LhsEval& T,
464 const LhsEval& pg,
465 const LhsEval& xgH2O,
466 const LhsEval& xgCO2)
467 {
468 Valgrind::CheckDefined(T);
469 Valgrind::CheckDefined(pg);
470 Valgrind::CheckDefined(xgH2O);
471 Valgrind::CheckDefined(xgCO2);
472
473 return CO2::gasDensity(T, pg);
474 }
475
476 /***********************************************************************/
477 /* */
478 /* Total brine density with dissolved CO2 */
479 /* rho_{b,CO2} = rho_w + contribution(salt) + contribution(CO2) */
480 /* */
481 /***********************************************************************/
482 template <class LhsEval>
483 static LhsEval liquidDensity_(const LhsEval& T,
484 const LhsEval& pl,
485 const LhsEval& xlH2O,
486 const LhsEval& xlCO2)
487 {
488 Valgrind::CheckDefined(T);
489 Valgrind::CheckDefined(pl);
490 Valgrind::CheckDefined(xlH2O);
491 Valgrind::CheckDefined(xlCO2);
492
493 auto cast = [](const auto d)
494 {
495#if HAVE_QUAD
496 if constexpr (std::is_same_v<decltype(d), const quad>)
497 return static_cast<double>(d);
498 else
499#endif
500 return d;
501 };
502
503 auto tostring = [cast](const auto& val) -> std::string
504 {
505 if constexpr (DenseAd::is_evaluation<LhsEval>::value) {
506 return std::to_string(cast(getValue(val.value())));
507 } else {
508 return std::to_string(cast(val));
509 }
510 };
511
512 if(T < 273.15) {
513 const std::string msg =
514 "Liquid density for Brine and CO2 is only "
515 "defined above 273.15K (is +"
516 + tostring(T)+ "K)";
517 throw NumericalProblem(msg);
518 }
519 if(pl >= 2.5e8) {
520 const std::string msg =
521 "Liquid density for Brine and CO2 is only "
522 "defined below 250MPa (is "
523 + tostring(pl) + "Pa)";
524 throw NumericalProblem(msg);
525 }
526
527 const LhsEval& rho_brine = Brine::liquidDensity(T, pl);
528 const LhsEval& rho_pure = H2O::liquidDensity(T, pl);
529 const LhsEval& rho_lCO2 = liquidDensityWaterCO2_(T, pl, xlH2O, xlCO2);
530 const LhsEval& contribCO2 = rho_lCO2 - rho_pure;
531
532 return rho_brine + contribCO2;
533 }
534
535 template <class LhsEval>
536 static LhsEval liquidDensityWaterCO2_(const LhsEval& temperature,
537 const LhsEval& pl,
538 const LhsEval& /*xlH2O*/,
539 const LhsEval& xlCO2)
540 {
541 Scalar M_CO2 = CO2::molarMass();
542 Scalar M_H2O = H2O::molarMass();
543
544 const LhsEval& tempC = temperature - 273.15; /* tempC : temperature in °C */
545 const LhsEval& rho_pure = H2O::liquidDensity(temperature, pl);
546 // calculate the mole fraction of CO2 in the liquid. note that xlH2O is available
547 // as a function parameter, but in the case of a pure gas phase the value of M_T
548 // for the virtual liquid phase can become very large
549 const LhsEval xlH2O = 1.0 - xlCO2;
550 const LhsEval& M_T = M_H2O * xlH2O + M_CO2 * xlCO2;
551 const LhsEval& V_phi =
552 (37.51 +
553 tempC*(-9.585e-2 +
554 tempC*(8.74e-4 -
555 tempC*5.044e-7))) / 1.0e6;
556 return 1/ (xlCO2 * V_phi/M_T + M_H2O * xlH2O / (rho_pure * M_T));
557 }
558
559 template <class LhsEval>
560 static LhsEval liquidEnthalpyBrineCO2_(const LhsEval& T,
561 const LhsEval& p,
562 Scalar S, // salinity
563 const LhsEval& X_CO2_w)
564 {
565 /* X_CO2_w : mass fraction of CO2 in brine */
566
567 /* same function as enthalpy_brine, only extended by CO2 content */
568
569 /*Numerical coefficents from PALLISER*/
570 static Scalar f[] = {
571 2.63500E-1, 7.48368E-6, 1.44611E-6, -3.80860E-10
572 };
573
574 /*Numerical coefficents from MICHAELIDES for the enthalpy of brine*/
575 static Scalar a[4][3] = {
576 { 9633.6, -4080.0, +286.49 },
577 { +166.58, +68.577, -4.6856 },
578 { -0.90963, -0.36524, +0.249667E-1 },
579 { +0.17965E-2, +0.71924E-3, -0.4900E-4 }
580 };
581
582 LhsEval theta, h_NaCl;
583 LhsEval h_ls1, d_h;
584 LhsEval delta_h;
585 LhsEval delta_hCO2, hg, hw;
586
587 theta = T - 273.15;
588
589 // Regularization
590 Scalar scalarTheta = scalarValue(theta);
591 Scalar S_lSAT = f[0] + scalarTheta*(f[1] + scalarTheta*(f[2] + scalarTheta*f[3]));
592 if (S > S_lSAT)
593 S = S_lSAT;
594
595 hw = H2O::liquidEnthalpy(T, p) /1E3; /* kJ/kg */
596
597 /*DAUBERT and DANNER*/
598 /*U=*/h_NaCl = (3.6710E4*T + 0.5*(6.2770E1)*T*T - ((6.6670E-2)/3)*T*T*T
599 +((2.8000E-5)/4)*(T*T*T*T))/(58.44E3)- 2.045698e+02; /* kJ/kg */
600
601 Scalar m = 1E3/58.44 * S/(1-S);
602 int i = 0;
603 int j = 0;
604 d_h = 0;
605
606 for (i = 0; i<=3; i++) {
607 for (j=0; j<=2; j++) {
608 d_h = d_h + a[i][j] * pow(theta, static_cast<Scalar>(i)) * std::pow(m, j);
609 }
610 }
611 /* heat of dissolution for halite according to Michaelides 1971 */
612 delta_h = (4.184/(1E3 + (58.44 * m)))*d_h;
613
614 /* Enthalpy of brine without CO2 */
615 h_ls1 =(1-S)*hw + S*h_NaCl + S*delta_h; /* kJ/kg */
616
617 /* heat of dissolution for CO2 according to Fig. 6 in Duan and Sun 2003. (kJ/kg)
618 In the relevant temperature ranges CO2 dissolution is
619 exothermal */
620 delta_hCO2 = (-57.4375 + T * 0.1325) * 1000/44;
621
622 /* enthalpy contribution of CO2 (kJ/kg) */
623 hg = CO2::gasEnthalpy(T, p)/1E3 + delta_hCO2;
624
625 /* Enthalpy of brine with dissolved CO2 */
626 return (h_ls1 - X_CO2_w*hw + hg*X_CO2_w)*1E3; /*J/kg*/
627 }
628};
629
630} // namespace Opm
631
632#endif
The base class for all fluid systems.
A class for the brine fluid properties.
Binary coefficients for brine and CO2.
A class for the CO2 fluid properties.
Provides the OPM specific exception classes.
Binary coefficients for water and CO2.
Binary coefficients for water and nitrogen.
Relations valid for an ideal gas.
A parameter cache which does nothing.
A simplistic class representing the fluid properties.
A simple version of pure water.
A generic class which tabulates all thermodynamic properties of a given component.
The base class for all fluid systems.
Definition BaseFluidSystem.hpp:46
Scalar Scalar
The type used for scalar quantities.
Definition BaseFluidSystem.hpp:51
Binary coefficients for brine and CO2.
Definition Brine_CO2.hpp:42
static Evaluation gasDiffCoeff(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate=false)
Binary diffusion coefficent [m^2/s] of water in the CO2 phase.
Definition Brine_CO2.hpp:56
static void calculateMoleFractions(const Evaluation &temperature, const Evaluation &pg, const Evaluation &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:97
static Evaluation liquidDiffCoeff(const Evaluation &, const Evaluation &)
Binary diffusion coefficent [m^2/s] of CO2 in the brine phase.
Definition Brine_CO2.hpp:73
A two-phase fluid system with water and CO2.
Definition BrineCO2FluidSystem.hpp:67
static const int CO2Idx
The index of the CO2 component.
Definition BrineCO2FluidSystem.hpp:165
static const int BrineIdx
The index of the brine component.
Definition BrineCO2FluidSystem.hpp:163
Brine_Tabulated Brine
The type of the component for brine used by the fluid system.
Definition BrineCO2FluidSystem.hpp:81
static void init()
Initialize the fluid system's static parameters.
Definition BrineCO2FluidSystem.hpp:199
static LhsEval heatCapacity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Specific isobaric heat capacity of a fluid phase [J/kg].
Definition BrineCO2FluidSystem.hpp:446
static const char * componentName(unsigned compIdx)
Return the human readable name of a component.
Definition BrineCO2FluidSystem.hpp:170
static const int gasPhaseIdx
The index of the gas phase.
Definition BrineCO2FluidSystem.hpp:98
static LhsEval thermalConductivity(const FluidState &, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Thermal conductivity of a fluid phase [W/(m K)].
Definition BrineCO2FluidSystem.hpp:421
static const char * phaseName(unsigned phaseIdx)
Return the human readable name of a fluid phase.
Definition BrineCO2FluidSystem.hpp:103
static const int numPhases
The number of phases considered by the fluid system.
Definition BrineCO2FluidSystem.hpp:93
BinaryCoeff::Brine_CO2< Scalar, H2O, CO2 > BinaryCoeffBrineCO2
The binary coefficients for brine and CO2 used by this fluid system.
Definition BrineCO2FluidSystem.hpp:86
::Opm::CO2< Scalar > CO2
The type of the component for pure CO2 used by the fluid system.
Definition BrineCO2FluidSystem.hpp:83
static Scalar molarMass(unsigned compIdx)
Return the molar mass of a component in [kg/mol].
Definition BrineCO2FluidSystem.hpp:184
static bool isIdealMixture(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal mixture.
Definition BrineCO2FluidSystem.hpp:139
static bool isCompressible(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be compressible.
Definition BrineCO2FluidSystem.hpp:149
static const int numComponents
Number of chemical species in the fluid system.
Definition BrineCO2FluidSystem.hpp:160
static const int liquidPhaseIdx
The index of the liquid phase.
Definition BrineCO2FluidSystem.hpp:96
static LhsEval enthalpy(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Given a phase's composition, temperature, pressure and density, calculate its specific enthalpy [J/kg...
Definition BrineCO2FluidSystem.hpp:387
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp, Scalar pressMin, Scalar pressMax, unsigned nPress)
Initialize the fluid system's static parameters using problem specific temperature and pressure range...
Definition BrineCO2FluidSystem.hpp:216
static LhsEval viscosity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the dynamic viscosity of a fluid phase [Pa*s].
Definition BrineCO2FluidSystem.hpp:288
static bool isIdealGas(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition BrineCO2FluidSystem.hpp:127
static LhsEval density(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the density [kg/m^3] of a fluid phase.
Definition BrineCO2FluidSystem.hpp:237
static LhsEval diffusionCoefficient(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 BrineCO2FluidSystem.hpp:369
static bool isLiquid(unsigned phaseIdx)
Return whether a phase is liquid.
Definition BrineCO2FluidSystem.hpp:117
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 BrineCO2FluidSystem.hpp:315
A class for the brine fluid properties.
Definition Brine.hpp:46
static Scalar salinity
The mass fraction of salt assumed to be in the brine.
Definition Brine.hpp:49
static Evaluation gasHeatCapacity(const Evaluation &temperature, const Evaluation &pressure)
Specific isobaric heat capacity of the component [J/kg] as a liquid.
Definition CO2.hpp:260
static Evaluation gasViscosity(Evaluation temperature, const Evaluation &pressure, bool extrapolate=false)
The dynamic viscosity [Pa s] of CO2.
Definition CO2.hpp:207
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &pressure, bool extrapolate=false)
Specific enthalpy of gaseous CO2 [J/kg].
Definition CO2.hpp:168
static const char * name()
A human readable name for the CO2.
Definition CO2.hpp:64
static bool gasIsIdeal()
Returns true iff the gas phase is assumed to be ideal.
Definition CO2.hpp:161
static Scalar molarMass()
The mass in [kg] of one mole of CO2.
Definition CO2.hpp:70
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:193
Material properties of pure water .
Definition H2O.hpp:65
A parameter cache which does nothing.
Definition NullParameterCache.hpp:40
A generic class which tabulates all thermodynamic properties of a given component.
Definition TabulatedComponent.hpp:56
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &pressure)
Specific enthalpy of the gas .
Definition TabulatedComponent.hpp:282
static Evaluation liquidHeatCapacity(const Evaluation &temperature, const Evaluation &pressure)
Specific isobaric heat capacity of the liquid .
Definition TabulatedComponent.hpp:333
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp, Scalar pressMin, Scalar pressMax, unsigned nPress)
Initialize the tables.
Definition TabulatedComponent.hpp:72
static Scalar molarMass()
The molar mass in of the component.
Definition TabulatedComponent.hpp:221
static Evaluation liquidViscosity(const Evaluation &temperature, const Evaluation &pressure)
The dynamic viscosity of liquid.
Definition TabulatedComponent.hpp:478
static Evaluation liquidDensity(const Evaluation &temperature, const Evaluation &pressure)
The density of liquid at a given pressure and temperature .
Definition TabulatedComponent.hpp:444
static Evaluation liquidEnthalpy(const Evaluation &temperature, const Evaluation &pressure)
Specific enthalpy of the liquid .
Definition TabulatedComponent.hpp:299
static const char * name()
A human readable name for the component.
Definition TabulatedComponent.hpp:215
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Definition BrineCO2FluidSystem.hpp:78