3.6-git
DUNE for Multi-{Phase, Component, Scale, Physics, ...} flow and transport in porous media
compositionalflash.hh
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 * See the file COPYING for full copying permissions. *
5 * *
6 * This program 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 3 of the License, or *
9 * (at your option) any later version. *
10 * *
11 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>. *
18 *****************************************************************************/
25#ifndef DUMUX_COMPOSITIONAL_FLASH_HH
26#define DUMUX_COMPOSITIONAL_FLASH_HH
27
28#include <dune/common/fvector.hh>
29
31
32namespace Dumux {
33
49template <class Scalar, class FluidSystem>
51{
53
54 enum { numPhases = FluidSystem::numPhases,
55 numComponents = FluidSystem::numComponents
56 };
57
58 enum{
59 phase0Idx = FluidSystem::phase0Idx,
60 phase1Idx = FluidSystem::phase1Idx,
61 comp0Idx = FluidSystem::comp0Idx,
62 comp1Idx = FluidSystem::comp1Idx
63 };
64
65public:
66 using ComponentVector = Dune::FieldVector<Scalar, numComponents>;
67 using PhaseVector = Dune::FieldVector<Scalar, numPhases>;
68
69
90 template<class FluidState>
91 static void concentrationFlash2p2c(FluidState& fluidState,
92 const Scalar Z0,
93 const PhaseVector& phasePressure,
94 const Scalar temperature)
95 {
96#ifndef NDEBUG
97 // this solver can only handle fluid systems which
98 // assume ideal mixtures of all fluids.
99 for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
100 assert(FluidSystem::isIdealMixture(phaseIdx));
101
102 }
103#endif
104
105 // set the temperature, pressure
106 fluidState.setTemperature(temperature);
107 fluidState.setPressure(phase0Idx, phasePressure[phase0Idx]);
108 fluidState.setPressure(phase1Idx, phasePressure[phase1Idx]);
109
110 // mole equilibrium ratios k for in case first phase is reference phase
111 const Scalar k10 = FluidSystem::fugacityCoefficient(fluidState, phase0Idx, comp0Idx) * fluidState.pressure(phase0Idx)
112 / (FluidSystem::fugacityCoefficient(fluidState, phase1Idx, comp0Idx) * fluidState.pressure(phase1Idx));
113 const Scalar k11 = FluidSystem::fugacityCoefficient(fluidState, phase0Idx, comp1Idx) * fluidState.pressure(phase0Idx)
114 / (FluidSystem::fugacityCoefficient(fluidState, phase1Idx, comp1Idx) * fluidState.pressure(phase1Idx));
115
116 // get mole fraction from equilibrium constants
117 fluidState.setMoleFraction(phase0Idx, comp0Idx, ((1. - k11) / (k10 - k11)));
118 fluidState.setMoleFraction(phase1Idx, comp0Idx, (fluidState.moleFraction(phase0Idx,comp0Idx) * k10));
119 fluidState.setMoleFraction(phase0Idx, comp1Idx, 1.0 - fluidState.moleFraction(phase0Idx,comp0Idx));
120 fluidState.setMoleFraction(phase1Idx, comp1Idx, 1.0 - fluidState.moleFraction(phase1Idx,comp0Idx));
121
122 // mass equilibrium ratios K for in case first phase is reference phase
123 const Scalar K10 = fluidState.massFraction(phase1Idx, comp0Idx) / fluidState.massFraction(phase0Idx, comp0Idx);
124 const Scalar K11 = (1. - fluidState.massFraction(phase1Idx, comp0Idx)) / (1. - fluidState.massFraction(phase0Idx, comp0Idx));
125
126 // phase mass fraction Nu (ratio of phase mass to total phase mass) of first phase
127 const Scalar Nu0 = 1. + ((Z0 * (K10 - 1.)) + ((1. - Z0) * (K11 - 1.))) / ((K11 - 1.) * (K10 - 1.));
128
129 // an array of the phase mass fractions from which we will compute the saturations
130 std::array<Scalar, 2> phaseMassFraction;
131
132 // check phase presence
133 if (Nu0 > 0. && Nu0 < 1.) // two phases present
134 phaseMassFraction[phase0Idx] = Nu0;
135 else if (Nu0 <= 0.) // only second phase present
136 {
137 phaseMassFraction[phase0Idx] = 0.0; // no first phase
138 fluidState.setMassFraction(phase1Idx,comp0Idx, Z0); // assign complete mass dissolved into second phase
139 }
140 else // only first phase present
141 {
142 phaseMassFraction[phase0Idx] = 1.0; // no second phase
143 fluidState.setMassFraction(phase0Idx, comp0Idx, Z0); // assign complete mass dissolved into first phase
144 }
145
146 // complete phase mass fractions
147 phaseMassFraction[phase1Idx] = 1.0 - phaseMassFraction[phase0Idx];
148
149 // get densities with correct composition
150 fluidState.setDensity(phase0Idx, FluidSystem::density(fluidState, phase0Idx));
151 fluidState.setDensity(phase1Idx, FluidSystem::density(fluidState, phase1Idx));
152 fluidState.setMolarDensity(phase0Idx, FluidSystem::molarDensity(fluidState, phase0Idx));
153 fluidState.setMolarDensity(phase1Idx, FluidSystem::molarDensity(fluidState, phase1Idx));
154
155 fluidState.setViscosity(phase0Idx, FluidSystem::viscosity(fluidState, phase0Idx));
156 fluidState.setViscosity(phase1Idx, FluidSystem::viscosity(fluidState, phase1Idx));
157
158 Scalar sw = phaseMassFraction[phase0Idx] / fluidState.density(phase0Idx);
159 sw /= (phaseMassFraction[phase0Idx] / fluidState.density(phase0Idx)
160 + phaseMassFraction[phase1Idx] / fluidState.density(phase1Idx));
161 fluidState.setSaturation(phase0Idx, sw);
162 fluidState.setSaturation(phase1Idx, 1.0-sw);
163 }
164
179 static void concentrationFlash1p2c(FluidState1p2c& fluidState, const Scalar& Z0,const Dune::FieldVector<Scalar,numPhases>
180 phasePressure,const int presentPhaseIdx, const Scalar& temperature)
181 {
182 // set the temperature, pressure
183 fluidState.setTemperature(temperature);
184 fluidState.setPressure(phase0Idx, phasePressure[phase0Idx]);
185 fluidState.setPressure(phase1Idx, phasePressure[phase1Idx]);
186
187 fluidState.setPresentPhaseIdx(presentPhaseIdx);
188 fluidState.setMassFraction(presentPhaseIdx,comp0Idx, Z0);
189
190 // transform mass to mole fractions
191 fluidState.setMoleFraction(presentPhaseIdx, comp0Idx, Z0 / FluidSystem::molarMass(comp0Idx)
192 / (Z0 / FluidSystem::molarMass(comp0Idx) + (1. - Z0) / FluidSystem::molarMass(comp1Idx)));
193
194 fluidState.setAverageMolarMass(presentPhaseIdx,
195 fluidState.massFraction(presentPhaseIdx, comp0Idx) * FluidSystem::molarMass(comp0Idx)
196 + fluidState.massFraction(presentPhaseIdx, comp1Idx) * FluidSystem::molarMass(comp1Idx));
197
198 fluidState.setDensity(presentPhaseIdx, FluidSystem::density(fluidState, presentPhaseIdx));
199 fluidState.setMolarDensity(presentPhaseIdx, FluidSystem::molarDensity(fluidState, presentPhaseIdx));
200
201 fluidState.setViscosity(presentPhaseIdx, FluidSystem::viscosity(fluidState, presentPhaseIdx));
202 }
204
206
218 template<class FluidState>
219 static void saturationFlash2p2c(FluidState& fluidState,
220 const Scalar saturation,
221 const PhaseVector& phasePressure,
222 const Scalar temperature)
223 {
224#ifndef NDEBUG
225 // this solver can only handle fluid systems which
226 // assume ideal mixtures of all fluids.
227 for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
228 assert(FluidSystem::isIdealMixture(phaseIdx));
229
230 }
231#endif
232
233 // set the temperature, pressure
234 fluidState.setTemperature(temperature);
235 fluidState.setPressure(phase0Idx, phasePressure[phase0Idx]);
236 fluidState.setPressure(phase1Idx, phasePressure[phase1Idx]);
237
238 // mole equilibrium ratios k for in case first phase is reference phase
239 const Scalar k10 = FluidSystem::fugacityCoefficient(fluidState, phase0Idx, comp0Idx) * fluidState.pressure(phase0Idx)
240 / (FluidSystem::fugacityCoefficient(fluidState, phase1Idx, comp0Idx) * fluidState.pressure(phase1Idx));
241 const Scalar k11 = FluidSystem::fugacityCoefficient(fluidState, phase0Idx, comp1Idx) * fluidState.pressure(phase0Idx)
242 / (FluidSystem::fugacityCoefficient(fluidState, phase1Idx, comp1Idx) * fluidState.pressure(phase1Idx));
243
244 // get mole fraction from equilibrium constants
245 fluidState.setMoleFraction(phase0Idx,comp0Idx, ((1. - k11) / (k10 - k11)));
246 fluidState.setMoleFraction(phase1Idx,comp0Idx, (fluidState.moleFraction(phase0Idx,comp0Idx) * k10));
247 fluidState.setMoleFraction(phase0Idx, comp1Idx, 1.0 - fluidState.moleFraction(phase0Idx,comp0Idx));
248 fluidState.setMoleFraction(phase1Idx, comp1Idx, 1.0 - fluidState.moleFraction(phase1Idx,comp0Idx));
249
250 // get densities with correct composition
251 fluidState.setDensity(phase0Idx, FluidSystem::density(fluidState, phase0Idx));
252 fluidState.setDensity(phase1Idx, FluidSystem::density(fluidState, phase1Idx));
253 fluidState.setMolarDensity(phase0Idx, FluidSystem::molarDensity(fluidState, phase0Idx));
254 fluidState.setMolarDensity(phase1Idx, FluidSystem::molarDensity(fluidState, phase1Idx));
255
256 fluidState.setViscosity(phase0Idx, FluidSystem::viscosity(fluidState, phase0Idx));
257 fluidState.setViscosity(phase1Idx, FluidSystem::viscosity(fluidState, phase1Idx));
258
259 // set saturation
260 fluidState.setSaturation(phase0Idx, saturation);
261 fluidState.setSaturation(phase1Idx, 1.0-saturation);
262 }
264};
265
266} // end namespace Dumux
267
268#endif
Calculates phase state for a single phase but two-component state.
Adaption of the non-isothermal two-phase two-component flow model to problems with CO2.
Definition: adapt.hh:29
std::string temperature() noexcept
I/O name of temperature for equilibrium models.
Definition: name.hh:51
std::string saturation(int phaseIdx) noexcept
I/O name of saturation for multiphase systems.
Definition: name.hh:43
std::string viscosity(int phaseIdx) noexcept
I/O name of viscosity for multiphase systems.
Definition: name.hh:74
std::string molarDensity(int phaseIdx) noexcept
I/O name of molar density for multiphase systems.
Definition: name.hh:83
std::string density(int phaseIdx) noexcept
I/O name of density for multiphase systems.
Definition: name.hh:65
Flash calculation routines for compositional sequential models.
Definition: compositionalflash.hh:51
static void saturationFlash2p2c(FluidState &fluidState, const Scalar saturation, const PhaseVector &phasePressure, const Scalar temperature)
Definition: compositionalflash.hh:219
Dune::FieldVector< Scalar, numComponents > ComponentVector
Definition: compositionalflash.hh:66
static void concentrationFlash1p2c(FluidState1p2c &fluidState, const Scalar &Z0, const Dune::FieldVector< Scalar, numPhases > phasePressure, const int presentPhaseIdx, const Scalar &temperature)
The simplest possible update routine for 1p2c "flash" calculations.
Definition: compositionalflash.hh:179
Dune::FieldVector< Scalar, numPhases > PhaseVector
Definition: compositionalflash.hh:67
static void concentrationFlash2p2c(FluidState &fluidState, const Scalar Z0, const PhaseVector &phasePressure, const Scalar temperature)
Definition: compositionalflash.hh:91
Container for compositional variables in a 1p2c situation.
Definition: pseudo1p2c.hh:44
void setAverageMolarMass(int phaseIdx, Scalar value)
Set the average molar mass of a fluid phase [kg/mol].
Definition: pseudo1p2c.hh:276
void setMassFraction(int phaseIdx, int compIdx, Scalar value)
Sets the mass fraction of a component in a phase.
Definition: pseudo1p2c.hh:216
void setPresentPhaseIdx(int phaseIdx)
Sets the phase Index that is present in this fluidState.
Definition: pseudo1p2c.hh:257
void setPressure(int phaseIdx, Scalar value)
Sets the phase pressure .
Definition: pseudo1p2c.hh:282
void setDensity(int phaseIdx, Scalar value)
Sets the density of a phase .
Definition: pseudo1p2c.hh:235
void setViscosity(int phaseIdx, Scalar value)
Sets the viscosity of a phase .
Definition: pseudo1p2c.hh:203
void setMolarDensity(int phaseIdx, Scalar value)
Set the molar density of a phase .
Definition: pseudo1p2c.hh:247
void setTemperature(Scalar value)
Sets the temperature.
Definition: pseudo1p2c.hh:265
Scalar massFraction(int phaseIdx, int compIdx) const
Returns the mass fraction of component in fluid phase in .
Definition: pseudo1p2c.hh:121
void setMoleFraction(int phaseIdx, int compIdx, Scalar value)
Sets the molar fraction of a component in a fluid phase.
Definition: pseudo1p2c.hh:226