version 3.10.0
Loading...
Searching...
No Matches
2pimmiscible.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// SPDX-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
5// SPDX-License-Identifier: GPL-3.0-or-later
6//
12#ifndef DUMUX_2P_IMMISCIBLE_FLUID_SYSTEM_HH
13#define DUMUX_2P_IMMISCIBLE_FLUID_SYSTEM_HH
14
15#include <limits>
16#include <cassert>
17
18#include <dune/common/exceptions.hh>
19
24#include <dumux/io/name.hh>
25
26#include "base.hh"
27
28namespace Dumux::FluidSystems {
29
43template <class Scalar, class Fluid0, class Fluid1>
45: public Base<Scalar, TwoPImmiscible<Scalar, Fluid0, Fluid1> >
46{
47 static_assert((Fluid0::numPhases == 1), "Fluid0 has more than one phase");
48 static_assert((Fluid1::numPhases == 1), "Fluid1 has more than one phase");
49 static_assert((Fluid0::numComponents == 1), "Fluid0 has more than one component");
50 static_assert((Fluid1::numComponents == 1), "Fluid1 has more than one component");
51 // two gaseous phases at once do not make sense physically! (but two liquids are fine)
52 static_assert(!Fluid0::isGas() || !Fluid1::isGas(), "One phase has to be a liquid!");
53
55
56public:
57 static constexpr int numPhases = 2;
58 static constexpr int numComponents = 2;
59
60 static constexpr int phase0Idx = 0;
61 static constexpr int phase1Idx = 1;
62 static constexpr int comp0Idx = 0;
63 static constexpr int comp1Idx = 1;
64
65 /****************************************
66 * Fluid phase related static parameters
67 ****************************************/
72 static std::string phaseName(int phaseIdx)
73 {
74 assert(0 <= phaseIdx && phaseIdx < numPhases);
75
76 if (!Fluid0::isGas() && !Fluid1::isGas())
77 {
80
81 if (name0 != name1)
82 return (phaseIdx == phase0Idx) ? name0 : name1;
83 else
84 return (phaseIdx == phase0Idx) ? name0 + "_0" : name1 + "_1";
85 }
86 else
87 {
88 if (phaseIdx == phase0Idx)
89 return Fluid0::isGas() ? IOName::gaseousPhase() : IOName::liquidPhase();
90 else
91 return Fluid1::isGas() ? IOName::gaseousPhase() : IOName::liquidPhase();
92 }
93 }
94
98 static constexpr bool isMiscible()
99 { return false; }
100
105 static constexpr bool isGas(int phaseIdx)
106 {
107 assert(0 <= phaseIdx && phaseIdx < numPhases);
108
109 if (phaseIdx == phase0Idx)
110 return Fluid0::isGas();
111 return Fluid1::isGas();
112 }
113
127 static bool isIdealMixture(int phaseIdx)
128 {
129 assert(0 <= phaseIdx && phaseIdx < numPhases);
130
131 // we assume immisibility
132 return true;
133 }
134
141 static constexpr bool isIdealGas(int phaseIdx)
142 {
143 assert(0 <= phaseIdx && phaseIdx < numPhases);
144
145 // let the fluids decide
146 if (phaseIdx == phase0Idx)
147 return Fluid0::isIdealGas();
148 return Fluid1::isIdealGas();
149 }
150
160 static constexpr bool isCompressible(int phaseIdx)
161 {
162 assert(0 <= phaseIdx && phaseIdx < numPhases);
163
164 // let the fluids decide
165 if (phaseIdx == phase0Idx)
166 return Fluid0::isCompressible();
167 return Fluid1::isCompressible();
168 }
169
175 static constexpr bool viscosityIsConstant(int phaseIdx)
176 {
177 assert(0 <= phaseIdx && phaseIdx < numPhases);
178
179 // let the fluids decide
180 if (phaseIdx == phase0Idx)
181 return Fluid0::viscosityIsConstant();
182 return Fluid1::viscosityIsConstant();
183 }
184
191 static bool isIdealFluid1(int phaseIdx)
192 {
193 assert(0 <= phaseIdx && phaseIdx < numPhases);
194
195 // let the fluids decide
196 if (phaseIdx == phase0Idx)
197 return Fluid0::isIdealFluid1();
198 return Fluid1::isIdealFluid1();
199 }
200
201 /****************************************
202 * Component related static parameters
203 ****************************************/
209 static std::string componentName(int compIdx)
210 {
211 assert(0 <= compIdx && compIdx < numComponents);
212
213 if (compIdx == comp0Idx)
214 return Fluid0::name();
215 return Fluid1::name();
216 }
217
222 static Scalar molarMass(int compIdx)
223 {
224 assert(0 <= compIdx && compIdx < numComponents);
225
226 if (compIdx == comp0Idx)
227 return Fluid0::molarMass();
228 return Fluid1::molarMass();
229 }
230
235 static Scalar criticalTemperature(int compIdx)
236 {
237 assert(0 <= compIdx && compIdx < numComponents);
238
239 if (compIdx == comp0Idx)
240 return Fluid0::criticalTemperature();
241 return Fluid1::criticalTemperature();
242 }
243
248 static Scalar criticalPressure(int compIdx)
249 {
250 assert(0 <= compIdx && compIdx < numComponents);
251
252 if (compIdx == comp0Idx)
253 return Fluid0::criticalPressure();
254 return Fluid1::criticalPressure();
255 }
256
261 static Scalar acentricFactor(int compIdx)
262 {
263 assert(0 <= compIdx && compIdx < numComponents);
264
265 if (compIdx == comp0Idx)
266 return Fluid0::acentricFactor();
267 return Fluid1::acentricFactor();
268 }
269
270 /****************************************
271 * thermodynamic relations
272 ****************************************/
273
277 static void init()
278 {
279 // initialize with some default values
280 init(/*tempMin=*/273.15, /*tempMax=*/623.15, /*numTemp=*/100,
281 /*pMin=*/-10.0, /*pMax=*/20e6, /*numP=*/200);
282 }
283
295 static void init(Scalar tempMin, Scalar tempMax, std::size_t nTemp,
296 Scalar pressMin, Scalar pressMax, std::size_t nPress)
297 {
298 if (Fluid0::Component::isTabulated)
299 Fluid0::Component::init(tempMin, tempMax, nTemp, pressMin, pressMax, nPress);
300
301 if (Fluid1::Component::isTabulated)
302 Fluid1::Component::init(tempMin, tempMax, nTemp, pressMin, pressMax, nPress);
303 }
304
305 using Base<Scalar, ThisType>::density;
307 template <class FluidState>
308 static Scalar density(const FluidState &fluidState,
309 int phaseIdx)
310 {
311 assert(0 <= phaseIdx && phaseIdx < numPhases);
312
313 Scalar temperature = fluidState.temperature(phaseIdx);
314 Scalar pressure = fluidState.pressure(phaseIdx);
315 if (phaseIdx == phase0Idx)
316 return Fluid0::density(temperature, pressure);
317 return Fluid1::density(temperature, pressure);
318 }
319
320 using Base<Scalar, ThisType>::molarDensity;
322 template <class FluidState>
323 static Scalar molarDensity(const FluidState &fluidState, int phaseIdx)
324 {
325 Scalar temperature = fluidState.temperature(phaseIdx);
326 Scalar pressure = fluidState.pressure(phaseIdx);
327 if (phaseIdx == phase0Idx)
328 return Fluid0::molarDensity(temperature, pressure);
329 return Fluid1::molarDensity(temperature, pressure);
330 }
331
332 using Base<Scalar, ThisType>::viscosity;
334 template <class FluidState>
335 static Scalar viscosity(const FluidState &fluidState,
336 int phaseIdx)
337 {
338 assert(0 <= phaseIdx && phaseIdx < numPhases);
339
340 Scalar temperature = fluidState.temperature(phaseIdx);
341 Scalar pressure = fluidState.pressure(phaseIdx);
342 if (phaseIdx == phase0Idx)
343 return Fluid0::viscosity(temperature, pressure);
344 return Fluid1::viscosity(temperature, pressure);
345 }
346
347 using Base<Scalar, ThisType>::fugacityCoefficient;
349 template <class FluidState>
350 static Scalar fugacityCoefficient(const FluidState &fluidState,
351 int phaseIdx,
352 int compIdx)
353 {
354 assert(0 <= phaseIdx && phaseIdx < numPhases);
355 assert(0 <= compIdx && compIdx < numComponents);
356
357 if (phaseIdx == compIdx)
358 // We could calculate the real fugacity coefficient of
359 // the component in the fluid. Probably that's not worth
360 // the effort, since the fugacity coefficient of the other
361 // component is infinite anyway...
362 return 1.0;
363 return std::numeric_limits<Scalar>::infinity();
364 }
365
366 using Base<Scalar, ThisType>::diffusionCoefficient;
368 template <class FluidState>
369 static Scalar diffusionCoefficient(const FluidState &fluidState,
370 int phaseIdx,
371 int compIdx)
372 {
373 DUNE_THROW(Dune::InvalidStateException,
374 "Diffusion coefficients of components are meaningless if"
375 " immiscibility is assumed");
376 }
377
380 template <class FluidState>
381 static Scalar binaryDiffusionCoefficient(const FluidState &fluidState,
382 int phaseIdx,
383 int compIIdx,
384 int compJIdx)
385
386 {
387 DUNE_THROW(Dune::InvalidStateException,
388 "Binary diffusion coefficients of components are meaningless if"
389 " immiscibility is assumed");
390 }
391
392 using Base<Scalar, ThisType>::enthalpy;
394 template <class FluidState>
395 static Scalar enthalpy(const FluidState &fluidState,
396 int phaseIdx)
397 {
398 assert(0 <= phaseIdx && phaseIdx < numPhases);
399
400 Scalar temperature = fluidState.temperature(phaseIdx);
401 Scalar pressure = fluidState.pressure(phaseIdx);
402 if (phaseIdx == phase0Idx)
403 return Fluid0::enthalpy(temperature, pressure);
404 return Fluid1::enthalpy(temperature, pressure);
405 }
406
407 using Base<Scalar, ThisType>::thermalConductivity;
409 template <class FluidState>
410 static Scalar thermalConductivity(const FluidState &fluidState,
411 int phaseIdx)
412 {
413 assert(0 <= phaseIdx && phaseIdx < numPhases);
414
415 Scalar temperature = fluidState.temperature(phaseIdx);
416 Scalar pressure = fluidState.pressure(phaseIdx);
417 if (phaseIdx == phase0Idx)
418 return Fluid0::thermalConductivity(temperature, pressure);
419 return Fluid1::thermalConductivity(temperature, pressure);
420 }
421
422 using Base<Scalar, ThisType>::heatCapacity;
424 template <class FluidState>
425 static Scalar heatCapacity(const FluidState &fluidState,
426 int phaseIdx)
427 {
428 assert(0 <= phaseIdx && phaseIdx < numPhases);
429
430 Scalar temperature = fluidState.temperature(phaseIdx);
431 Scalar pressure = fluidState.pressure(phaseIdx);
432 if (phaseIdx == phase0Idx)
433 return Fluid0::heatCapacity(temperature, pressure);
434 return Fluid1::heatCapacity(temperature, pressure);
435 }
436};
437
438} // end namespace Dumux::FluidSystems
439
440#endif
A gaseous phase consisting of a single component.
A liquid phase consisting of a single component.
Fluid system base class.
Definition fluidsystems/base.hh:32
A fluid system for two-phase models assuming immiscibility and thermodynamic equilibrium.
Definition 2pimmiscible.hh:46
static Scalar binaryDiffusionCoefficient(const FluidState &fluidState, int phaseIdx, int compIIdx, int compJIdx)
Given a phase's composition, temperature and pressure, return the binary diffusion coefficient for c...
Definition 2pimmiscible.hh:381
static std::string phaseName(int phaseIdx)
Return the human readable name of a fluid phase.
Definition 2pimmiscible.hh:72
static std::string componentName(int compIdx)
Return the human readable name of a component.
Definition 2pimmiscible.hh:209
static constexpr bool isCompressible(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be compressible.
Definition 2pimmiscible.hh:160
static Scalar acentricFactor(int compIdx)
The acentric factor of a component .
Definition 2pimmiscible.hh:261
static Scalar enthalpy(const FluidState &fluidState, int phaseIdx)
Given a phase's composition, temperature, pressure and density, calculate its specific enthalpy .
Definition 2pimmiscible.hh:395
static constexpr bool isMiscible()
Returns whether the fluids are miscible.
Definition 2pimmiscible.hh:98
static bool isIdealFluid1(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition 2pimmiscible.hh:191
static Scalar thermalConductivity(const FluidState &fluidState, int phaseIdx)
Thermal conductivity of a fluid phase .
Definition 2pimmiscible.hh:410
static bool isIdealMixture(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal mixture.
Definition 2pimmiscible.hh:127
static void init(Scalar tempMin, Scalar tempMax, std::size_t nTemp, Scalar pressMin, Scalar pressMax, std::size_t nPress)
Initialize the fluid system's static parameters using problem specific temperature and pressure range...
Definition 2pimmiscible.hh:295
static Scalar viscosity(const FluidState &fluidState, int phaseIdx)
Calculate the dynamic viscosity of a fluid phase .
Definition 2pimmiscible.hh:335
static Scalar fugacityCoefficient(const FluidState &fluidState, int phaseIdx, int compIdx)
Calculate the fugacity coefficient of an individual component in a fluid phase.
Definition 2pimmiscible.hh:350
static Scalar diffusionCoefficient(const FluidState &fluidState, int phaseIdx, int compIdx)
Calculate the binary molecular diffusion coefficient for a component in a fluid phase .
Definition 2pimmiscible.hh:369
static constexpr bool isIdealGas(int phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition 2pimmiscible.hh:141
static constexpr int comp0Idx
index of the first component
Definition 2pimmiscible.hh:62
static Scalar heatCapacity(const FluidState &fluidState, int phaseIdx)
Specific isobaric heat capacity of a fluid phase .
Definition 2pimmiscible.hh:425
static constexpr int phase0Idx
index of the first phase
Definition 2pimmiscible.hh:60
static Scalar density(const FluidState &fluidState, int phaseIdx)
Calculate the density of a fluid phase.
Definition 2pimmiscible.hh:308
static constexpr bool viscosityIsConstant(int phaseIdx)
Returns true if the liquid phase viscostiy is constant.
Definition 2pimmiscible.hh:175
static constexpr int numPhases
Number of phases in the fluid system.
Definition 2pimmiscible.hh:57
static Scalar molarDensity(const FluidState &fluidState, int phaseIdx)
Calculate the molar density of a fluid phase.
Definition 2pimmiscible.hh:323
static void init()
Initialize the fluid system's static parameters.
Definition 2pimmiscible.hh:277
static Scalar criticalPressure(int compIdx)
Critical pressure of a component .
Definition 2pimmiscible.hh:248
static Scalar criticalTemperature(int compIdx)
Critical temperature of a component .
Definition 2pimmiscible.hh:235
static constexpr bool isGas(int phaseIdx)
Return whether a phase is gaseous.
Definition 2pimmiscible.hh:105
static constexpr int comp1Idx
index of the second component
Definition 2pimmiscible.hh:63
static Scalar molarMass(int compIdx)
Return the molar mass of a component in .
Definition 2pimmiscible.hh:222
static constexpr int numComponents
Number of components in the fluid system.
Definition 2pimmiscible.hh:58
static constexpr int phase1Idx
index of the second phase
Definition 2pimmiscible.hh:61
Base class for all components Components provide the thermodynamic relations for the liquid,...
Fluid system base class.
Represents all relevant thermodynamic quantities of a multi-phase fluid system assuming immiscibility...
A collection of input/output field names for common physical quantities.
Definition h2o.hh:901
std::string gaseousPhase() noexcept
I/O name of gaseous phase.
Definition name.hh:111
std::string naplPhase() noexcept
I/O name of napl phase.
Definition name.hh:119
std::string liquidPhase() noexcept
I/O name of liquid phase.
Definition name.hh:107
std::string aqueousPhase() noexcept
I/O name of aqueous phase.
Definition name.hh:115
IsAqueous struct.
Definition components/base.hh:34