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
40#include <opm/material/components/CO2Tables.hpp>
44
48
49#include <string_view>
50
51namespace Opm {
52
60template <class Scalar>
62 : public BaseFluidSystem<Scalar, BrineCO2FluidSystem<Scalar> >
63{
64 typedef ::Opm::H2O<Scalar> H2O_IAPWS;
65 typedef ::Opm::Brine<Scalar, H2O_IAPWS> Brine_IAPWS;
68
69 typedef H2O_Tabulated H2O;
70
71public:
72 template <class Evaluation>
73 struct ParameterCache : public NullParameterCache<Evaluation>
74 {};
75
79 typedef ::Opm::CO2<Scalar> CO2;
80
83
84 /****************************************
85 * Fluid phase related static parameters
86 ****************************************/
87
89 static const int numPhases = 2;
90
92 static const int liquidPhaseIdx = 0;
94 static const int gasPhaseIdx = 1;
95
99 static std::string_view phaseName(unsigned phaseIdx)
100 {
101 static const std::string_view name[] = {
102 "liquid",
103 "gas"
104 };
105
106 assert(phaseIdx < numPhases);
107 return name[phaseIdx];
108 }
109
113 static bool isLiquid(unsigned phaseIdx)
114 {
115 assert(phaseIdx < numPhases);
116
117 return phaseIdx != gasPhaseIdx;
118 }
119
123 static bool isIdealGas(unsigned phaseIdx)
124 {
125 assert(phaseIdx < numPhases);
126
127 if (phaseIdx == gasPhaseIdx)
128 return CO2::gasIsIdeal();
129 return false;
130 }
131
135 static bool isIdealMixture([[maybe_unused]] unsigned phaseIdx)
136 {
137 assert(phaseIdx < numPhases);
138
139 return true;
140 }
141
145 static bool isCompressible([[maybe_unused]] unsigned phaseIdx)
146 {
147 assert(phaseIdx < numPhases);
148
149 return true;
150 }
151
152 /****************************************
153 * Component related static parameters
154 ****************************************/
156 static const int numComponents = 2;
157
159 static const int BrineIdx = 0;
161 static const int CO2Idx = 1;
162
166 static std::string_view componentName(unsigned compIdx)
167 {
168 static const std::string_view name[] = {
169 Brine::name(),
170 CO2::name(),
171 };
172
173 assert(compIdx < numComponents);
174 return name[compIdx];
175 }
176
180 static Scalar molarMass(unsigned compIdx)
181 {
182 assert(compIdx < numComponents);
183 return (compIdx==BrineIdx)
185 : CO2::molarMass();
186 }
187
188 /****************************************
189 * thermodynamic relations
190 ****************************************/
191
195 static void init()
196 {
197 init(/*startTemp=*/273.15, /*endTemp=*/623.15, /*tempSteps=*/50,
198 /*startPressure=*/1e4, /*endPressure=*/40e6, /*pressureSteps=*/50);
199 }
200
212 static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp,
213 Scalar pressMin, Scalar pressMax, unsigned nPress)
214 {
215 if (H2O::isTabulated) {
216 H2O_Tabulated::init(tempMin, tempMax, nTemp,
217 pressMin, pressMax, nPress);
218 }
219
220 // set the salinity of brine to the one used by the CO2 tables
221 Brine_IAPWS::salinity = CO2::brineSalinity;
222
223 if (Brine::isTabulated) {
224 Brine_Tabulated::init(tempMin, tempMax, nTemp,
225 pressMin, pressMax, nPress);
226 }
227 }
228
232 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
233 static LhsEval density(const FluidState& fluidState,
234 const ParameterCache<ParamCacheEval>& /*paramCache*/,
235 unsigned phaseIdx)
236 {
237 assert(phaseIdx < numPhases);
238
239 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
240 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
241
242 if (phaseIdx == liquidPhaseIdx) {
243 // use normalized composition for to calculate the density
244 // (the relations don't seem to take non-normalized
245 // compositions too well...)
246 LhsEval xlBrine = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, BrineIdx))));
247 LhsEval xlCO2 = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, CO2Idx))));
248 LhsEval sumx = xlBrine + xlCO2;
249 xlBrine /= sumx;
250 xlCO2 /= sumx;
251
252 LhsEval result = liquidDensity_(temperature,
253 pressure,
254 xlBrine,
255 xlCO2);
256
257 Valgrind::CheckDefined(result);
258 return result;
259 }
260
261 assert(phaseIdx == gasPhaseIdx);
262
263 // use normalized composition for to calculate the density
264 // (the relations don't seem to take non-normalized
265 // compositions too well...)
266 LhsEval xgBrine = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, BrineIdx))));
267 LhsEval xgCO2 = min(1.0, max(0.0, decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, CO2Idx))));
268 LhsEval sumx = xgBrine + xgCO2;
269 xgBrine /= sumx;
270 xgCO2 /= sumx;
271
272 LhsEval result = gasDensity_(temperature,
273 pressure,
274 xgBrine,
275 xgCO2);
276 Valgrind::CheckDefined(result);
277 return result;
278 }
279
283 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
284 static LhsEval viscosity(const FluidState& fluidState,
285 const ParameterCache<ParamCacheEval>& /*paramCache*/,
286 unsigned phaseIdx)
287 {
288 assert(phaseIdx < numPhases);
289
290 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
291 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
292
293 if (phaseIdx == liquidPhaseIdx) {
294 // assume pure brine for the liquid phase. TODO: viscosity
295 // of mixture
296 LhsEval result = Brine::liquidViscosity(temperature, pressure);
297 Valgrind::CheckDefined(result);
298 return result;
299 }
300
301 assert(phaseIdx == gasPhaseIdx);
302 LhsEval result = CO2::gasViscosity(getTableInstance(), temperature, pressure);
303 Valgrind::CheckDefined(result);
304 return result;
305 }
306
310 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
311 static LhsEval fugacityCoefficient(const FluidState& fluidState,
312 const ParameterCache<ParamCacheEval>& /*paramCache*/,
313 unsigned phaseIdx,
314 unsigned compIdx)
315 {
316 assert(phaseIdx < numPhases);
317 assert(compIdx < numComponents);
318
319 if (phaseIdx == gasPhaseIdx)
320 // use the fugacity coefficients of an ideal gas. the
321 // actual value of the fugacity is not relevant, as long
322 // as the relative fluid compositions are observed,
323 return 1.0;
324
325 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
326 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
327 assert(temperature > 0);
328 assert(pressure > 0);
329
330 // Activity model for salt-out effect in brine-CO2 mutual solubility
331 // 2 = Duan & Sun as modified in Spycher & Pruess, Trans. Porous Media, (2009)
332 const int activityModel = 3;
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 temperature,
341 pressure,
342 LhsEval(Brine_IAPWS::salinity),
343 /*knownPhaseIdx=*/-1,
344 xlCO2,
345 xgH2O,
346 activityModel);
347
348 // normalize the phase compositions
349 xlCO2 = max(0.0, min(1.0, xlCO2));
350 xgH2O = max(0.0, min(1.0, xgH2O));
351
352 xlH2O = 1.0 - xlCO2;
353 xgCO2 = 1.0 - xgH2O;
354
355 if (compIdx == BrineIdx) {
356 Scalar phigH2O = 1.0;
357 return phigH2O * xgH2O / xlH2O;
358 }
359 else {
360 assert(compIdx == CO2Idx);
361
362 Scalar phigCO2 = 1.0;
363 return phigCO2 * xgCO2 / xlCO2;
364 };
365 }
366
370 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
371 static LhsEval diffusionCoefficient(const FluidState& fluidState,
372 const ParameterCache<ParamCacheEval>& /*paramCache*/,
373 unsigned phaseIdx,
374 unsigned /*compIdx*/)
375 {
376 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
377 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
378 if (phaseIdx == liquidPhaseIdx)
379 return BinaryCoeffBrineCO2::liquidDiffCoeff(temperature, pressure);
380
381 assert(phaseIdx == gasPhaseIdx);
382 return BinaryCoeffBrineCO2::gasDiffCoeff(getTableInstance(), temperature, pressure);
383 }
384
388 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
389 static LhsEval enthalpy(const FluidState& fluidState,
390 const ParameterCache<ParamCacheEval>& /*paramCache*/,
391 unsigned phaseIdx)
392 {
393 assert(phaseIdx < numPhases);
394
395 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
396 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
397
398 if (phaseIdx == liquidPhaseIdx) {
399 const LhsEval& XlCO2 = decay<LhsEval>(fluidState.massFraction(phaseIdx, CO2Idx));
400 const LhsEval& result = liquidEnthalpyBrineCO2_(temperature,
401 pressure,
403 XlCO2);
404 Valgrind::CheckDefined(result);
405 return result;
406 }
407 else {
408 const LhsEval& XCO2 = decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, CO2Idx));
409 const LhsEval& XBrine = decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, BrineIdx));
410
411 LhsEval result = 0;
412 result += XBrine * Brine::gasEnthalpy(temperature, pressure);
413 result += XCO2 * CO2::gasEnthalpy(getTableInstance(), temperature, pressure);
414 Valgrind::CheckDefined(result);
415 return result;
416 }
417 }
418
422 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
423 static LhsEval thermalConductivity(const FluidState& /*fluidState*/,
424 const ParameterCache<ParamCacheEval>& /*paramCache*/,
425 unsigned phaseIdx)
426 {
427 // TODO way too simple!
428 if (phaseIdx == liquidPhaseIdx)
429 return 0.6; // conductivity of water[W / (m K ) ]
430
431 // gas phase
432 return 0.025; // conductivity of air [W / (m K ) ]
433 }
434
447 template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
448 static LhsEval heatCapacity(const FluidState& fluidState,
449 const ParameterCache<ParamCacheEval>& /*paramCache*/,
450 unsigned phaseIdx)
451 {
452 assert(phaseIdx < numPhases);
453
454 const LhsEval& temperature = decay<LhsEval>(fluidState.temperature(phaseIdx));
455 const LhsEval& pressure = decay<LhsEval>(fluidState.pressure(phaseIdx));
456
457 if(phaseIdx == liquidPhaseIdx){
458 return H2O::liquidHeatCapacity(temperature, pressure);
459 }
460 else{
461 return CO2::gasHeatCapacity(temperature, pressure);
462 }
463 }
464
465private:
466 static const CO2Tables<double, std::vector<double>>& getTableInstance() {
468 return instance;
469 }
470
471 template <class LhsEval>
472 static LhsEval gasDensity_(const LhsEval& T,
473 const LhsEval& pg,
474 const LhsEval& xgH2O,
475 const LhsEval& xgCO2)
476 {
477 Valgrind::CheckDefined(T);
478 Valgrind::CheckDefined(pg);
479 Valgrind::CheckDefined(xgH2O);
480 Valgrind::CheckDefined(xgCO2);
481
482 return CO2::gasDensity(getTableInstance(), T, pg);
483 }
484
485 /***********************************************************************/
486 /* */
487 /* Total brine density with dissolved CO2 */
488 /* rho_{b,CO2} = rho_w + contribution(salt) + contribution(CO2) */
489 /* */
490 /***********************************************************************/
491 template <class LhsEval>
492 static LhsEval liquidDensity_(const LhsEval& T,
493 const LhsEval& pl,
494 const LhsEval& xlH2O,
495 const LhsEval& xlCO2)
496 {
497 Valgrind::CheckDefined(T);
498 Valgrind::CheckDefined(pl);
499 Valgrind::CheckDefined(xlH2O);
500 Valgrind::CheckDefined(xlCO2);
501
502 auto cast = [](const auto d)
503 {
504#if HAVE_QUAD
505 if constexpr (std::is_same_v<decltype(d), const quad>)
506 return static_cast<double>(d);
507 else
508#endif
509 return d;
510 };
511
512 auto tostring = [cast](const auto& val) -> std::string
513 {
514 if constexpr (DenseAd::is_evaluation<LhsEval>::value) {
515 return std::to_string(cast(getValue(val.value())));
516 } else {
517 return std::to_string(cast(val));
518 }
519 };
520
521 if(T < 273.15) {
522 const std::string msg =
523 "Liquid density for Brine and CO2 is only "
524 "defined above 273.15K (is +"
525 + tostring(T)+ "K)";
526 throw NumericalProblem(msg);
527 }
528 if(pl >= 2.5e8) {
529 const std::string msg =
530 "Liquid density for Brine and CO2 is only "
531 "defined below 250MPa (is "
532 + tostring(pl) + "Pa)";
533 throw NumericalProblem(msg);
534 }
535
536 const LhsEval& rho_brine = Brine::liquidDensity(T, pl);
537 const LhsEval& rho_pure = H2O::liquidDensity(T, pl);
538 const LhsEval& rho_lCO2 = liquidDensityWaterCO2_(T, pl, xlH2O, xlCO2);
539 const LhsEval& contribCO2 = rho_lCO2 - rho_pure;
540
541 return rho_brine + contribCO2;
542 }
543
544 template <class LhsEval>
545 static LhsEval liquidDensityWaterCO2_(const LhsEval& temperature,
546 const LhsEval& pl,
547 const LhsEval& /*xlH2O*/,
548 const LhsEval& xlCO2)
549 {
550 Scalar M_CO2 = CO2::molarMass();
551 Scalar M_H2O = H2O::molarMass();
552
553 const LhsEval& tempC = temperature - 273.15; /* tempC : temperature in °C */
554 const LhsEval& rho_pure = H2O::liquidDensity(temperature, pl);
555 // calculate the mole fraction of CO2 in the liquid. note that xlH2O is available
556 // as a function parameter, but in the case of a pure gas phase the value of M_T
557 // for the virtual liquid phase can become very large
558 const LhsEval xlH2O = 1.0 - xlCO2;
559 const LhsEval& M_T = M_H2O * xlH2O + M_CO2 * xlCO2;
560 const LhsEval& V_phi =
561 (37.51 +
562 tempC*(-9.585e-2 +
563 tempC*(8.74e-4 -
564 tempC*5.044e-7))) / 1.0e6;
565 return 1/ (xlCO2 * V_phi/M_T + M_H2O * xlH2O / (rho_pure * M_T));
566 }
567
568 template <class LhsEval>
569 static LhsEval liquidEnthalpyBrineCO2_(const LhsEval& T,
570 const LhsEval& p,
571 Scalar S, // salinity
572 const LhsEval& X_CO2_w)
573 {
574 /* X_CO2_w : mass fraction of CO2 in brine */
575
576 /* same function as enthalpy_brine, only extended by CO2 content */
577
578 /*Numerical coefficents from PALLISER*/
579 static const Scalar f[] = {
580 2.63500E-1, 7.48368E-6, 1.44611E-6, -3.80860E-10
581 };
582
583 /*Numerical coefficents from MICHAELIDES for the enthalpy of brine*/
584 static const Scalar a[4][3] = {
585 { 9633.6, -4080.0, +286.49 },
586 { +166.58, +68.577, -4.6856 },
587 { -0.90963, -0.36524, +0.249667E-1 },
588 { +0.17965E-2, +0.71924E-3, -0.4900E-4 }
589 };
590
591 LhsEval theta, h_NaCl;
592 LhsEval h_ls1, d_h;
593 LhsEval delta_h;
594 LhsEval delta_hCO2, hg, hw;
595
596 theta = T - 273.15;
597
598 // Regularization
599 Scalar scalarTheta = scalarValue(theta);
600 Scalar S_lSAT = f[0] + scalarTheta*(f[1] + scalarTheta*(f[2] + scalarTheta*f[3]));
601 if (S > S_lSAT)
602 S = S_lSAT;
603
604 hw = H2O::liquidEnthalpy(T, p) /1E3; /* kJ/kg */
605
606 /*DAUBERT and DANNER*/
607 /*U=*/h_NaCl = (3.6710E4*T + 0.5*(6.2770E1)*T*T - ((6.6670E-2)/3)*T*T*T
608 +((2.8000E-5)/4)*(T*T*T*T))/(58.44E3)- 2.045698e+02; /* kJ/kg */
609
610 Scalar m = 1E3/58.44 * S/(1-S);
611 d_h = 0;
612
613 for (int i = 0; i <= 3; ++i) {
614 for (int j = 0; j <= 2; ++j) {
615 d_h = d_h + a[i][j] * pow(theta, static_cast<Scalar>(i)) * std::pow(m, j);
616 }
617 }
618 /* heat of dissolution for halite according to Michaelides 1971 */
619 delta_h = (4.184/(1E3 + (58.44 * m)))*d_h;
620
621 /* Enthalpy of brine without CO2 */
622 h_ls1 =(1-S)*hw + S*h_NaCl + S*delta_h; /* kJ/kg */
623
624 /* heat of dissolution for CO2 according to Fig. 6 in Duan and Sun 2003. (kJ/kg)
625 In the relevant temperature ranges CO2 dissolution is
626 exothermal */
627 delta_hCO2 = (-57.4375 + T * 0.1325) * 1000/44;
628
629 /* enthalpy contribution of CO2 (kJ/kg) */
630 hg = CO2::gasEnthalpy(getTableInstance(), T, p)/1E3 + delta_hCO2;
631
632 /* Enthalpy of brine with dissolved CO2 */
633 return (h_ls1 - X_CO2_w*hw + hg*X_CO2_w)*1E3; /*J/kg*/
634 }
635};
636
637} // namespace Opm
638
639#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:43
Scalar Scalar
The type used for scalar quantities.
Definition BaseFluidSystem.hpp:48
Binary coefficients for brine and CO2.
Definition Brine_CO2.hpp:46
static OPM_HOST_DEVICE Evaluation liquidDiffCoeff(const Evaluation &, const Evaluation &)
Binary diffusion coefficent [m^2/s] of CO2 in the brine phase.
Definition Brine_CO2.hpp:77
static OPM_HOST_DEVICE void calculateMoleFractions(const CO2Params &params, const Evaluation &temperature, const Evaluation &pg, const Evaluation &salinity, const int knownPhaseIdx, Evaluation &xlCO2, Evaluation &ygH2O, const int &activityModel, 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:101
static OPM_HOST_DEVICE Evaluation gasDiffCoeff(const CO2Params &params, 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:60
A two-phase fluid system with water and CO2.
Definition BrineCO2FluidSystem.hpp:63
static const int CO2Idx
The index of the CO2 component.
Definition BrineCO2FluidSystem.hpp:161
static const int BrineIdx
The index of the brine component.
Definition BrineCO2FluidSystem.hpp:159
Brine_Tabulated Brine
The type of the component for brine used by the fluid system.
Definition BrineCO2FluidSystem.hpp:77
static std::string_view componentName(unsigned compIdx)
Return the human readable name of a component.
Definition BrineCO2FluidSystem.hpp:166
static void init()
Initialize the fluid system's static parameters.
Definition BrineCO2FluidSystem.hpp:195
static LhsEval heatCapacity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Specific isobaric heat capacity of a fluid phase [J/kg].
Definition BrineCO2FluidSystem.hpp:448
static const int gasPhaseIdx
The index of the gas phase.
Definition BrineCO2FluidSystem.hpp:94
static LhsEval thermalConductivity(const FluidState &, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Thermal conductivity of a fluid phase [W/(m K)].
Definition BrineCO2FluidSystem.hpp:423
static const int numPhases
The number of phases considered by the fluid system.
Definition BrineCO2FluidSystem.hpp:89
BinaryCoeff::Brine_CO2< Scalar, H2O, CO2 > BinaryCoeffBrineCO2
The binary coefficients for brine and CO2 used by this fluid system.
Definition BrineCO2FluidSystem.hpp:82
::Opm::CO2< Scalar > CO2
The type of the component for pure CO2 used by the fluid system.
Definition BrineCO2FluidSystem.hpp:79
static Scalar molarMass(unsigned compIdx)
Return the molar mass of a component in [kg/mol].
Definition BrineCO2FluidSystem.hpp:180
static bool isIdealMixture(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal mixture.
Definition BrineCO2FluidSystem.hpp:135
static bool isCompressible(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be compressible.
Definition BrineCO2FluidSystem.hpp:145
static const int numComponents
Number of chemical species in the fluid system.
Definition BrineCO2FluidSystem.hpp:156
static const int liquidPhaseIdx
The index of the liquid phase.
Definition BrineCO2FluidSystem.hpp:92
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:389
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:212
static LhsEval viscosity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the dynamic viscosity of a fluid phase [Pa*s].
Definition BrineCO2FluidSystem.hpp:284
static bool isIdealGas(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition BrineCO2FluidSystem.hpp:123
static std::string_view phaseName(unsigned phaseIdx)
Return the human readable name of a fluid phase.
Definition BrineCO2FluidSystem.hpp:99
static LhsEval density(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the density [kg/m^3] of a fluid phase.
Definition BrineCO2FluidSystem.hpp:233
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:371
static bool isLiquid(unsigned phaseIdx)
Return whether a phase is liquid.
Definition BrineCO2FluidSystem.hpp:113
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:311
A class for the brine fluid properties.
Definition Brine.hpp:48
static Scalar salinity
The mass fraction of salt assumed to be in the brine.
Definition Brine.hpp:51
Definition CO2Tables.hpp:60
static OPM_HOST_DEVICE std::string_view name()
A human readable name for the CO2.
Definition CO2.hpp:67
static OPM_HOST_DEVICE Evaluation gasDensity(const Params &params, 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:222
static OPM_HOST_DEVICE Scalar molarMass()
The mass in [kg] of one mole of CO2.
Definition CO2.hpp:73
static OPM_HOST_DEVICE bool gasIsIdeal()
Returns true iff the gas phase is assumed to be ideal.
Definition CO2.hpp:164
static OPM_HOST_DEVICE Evaluation gasHeatCapacity(const Params &params, const Evaluation &temperature, const Evaluation &pressure)
Specific isobaric heat capacity of the component [J/kg] as a liquid.
Definition CO2.hpp:316
static OPM_HOST_DEVICE Evaluation gasEnthalpy(const Params &params, const Evaluation &temperature, const Evaluation &pressure, bool extrapolate=false)
Specific enthalpy of gaseous CO2 [J/kg].
Definition CO2.hpp:171
static OPM_HOST_DEVICE Evaluation gasViscosity(const Params &params, Evaluation temperature, const Evaluation &pressure, bool extrapolate=false)
The dynamic viscosity [Pa s] of CO2.
Definition CO2.hpp:249
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 std::string_view name()
A human readable name for the component.
Definition TabulatedComponent.hpp:215
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
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Definition BrineCO2FluidSystem.hpp:74