| Line | Branch | Exec | Source |
|---|---|---|---|
| 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-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder | ||
| 5 | // SPDX-License-Identifier: GPL-3.0-or-later | ||
| 6 | // | ||
| 7 | /*! | ||
| 8 | * \file | ||
| 9 | * \ingroup RichardsNCModel | ||
| 10 | * \brief Contains the quantities which are constant within a | ||
| 11 | * finite volume in the Richards, n-component model. | ||
| 12 | */ | ||
| 13 | |||
| 14 | #ifndef DUMUX_RICHARDSNC_VOLUME_VARIABLES_HH | ||
| 15 | #define DUMUX_RICHARDSNC_VOLUME_VARIABLES_HH | ||
| 16 | |||
| 17 | #include <algorithm> | ||
| 18 | #include <array> | ||
| 19 | |||
| 20 | #include <dumux/porousmediumflow/volumevariables.hh> | ||
| 21 | #include <dumux/porousmediumflow/nonisothermal/volumevariables.hh> | ||
| 22 | #include <dumux/material/solidstates/updatesolidvolumefractions.hh> | ||
| 23 | |||
| 24 | namespace Dumux { | ||
| 25 | |||
| 26 | /*! | ||
| 27 | * \ingroup RichardsNCModel | ||
| 28 | * \brief Contains the quantities which are constant within a | ||
| 29 | * finite volume in the Richards, n-component model. | ||
| 30 | */ | ||
| 31 | template <class Traits> | ||
| 32 | 8312652 | class RichardsNCVolumeVariables | |
| 33 | : public PorousMediumFlowVolumeVariables<Traits> | ||
| 34 | , public EnergyVolumeVariables<Traits, RichardsNCVolumeVariables<Traits> > | ||
| 35 | { | ||
| 36 | |||
| 37 | using ParentType = PorousMediumFlowVolumeVariables<Traits>; | ||
| 38 | using EnergyVolVars = EnergyVolumeVariables<Traits, RichardsNCVolumeVariables<Traits> >; | ||
| 39 | using Scalar = typename Traits::PrimaryVariables::value_type; | ||
| 40 | using PermeabilityType = typename Traits::PermeabilityType; | ||
| 41 | |||
| 42 | static constexpr int numFluidComps = ParentType::numFluidComponents(); | ||
| 43 | static constexpr bool useMoles = Traits::ModelTraits::useMoles(); | ||
| 44 | |||
| 45 | using EffDiffModel = typename Traits::EffectiveDiffusivityModel; | ||
| 46 | using DiffusionCoefficients = typename Traits::DiffusionType::DiffusionCoefficientsContainer; | ||
| 47 | |||
| 48 | public: | ||
| 49 | //! Export type of the fluid system | ||
| 50 | using FluidSystem = typename Traits::FluidSystem; | ||
| 51 | //! Export type of the fluid state | ||
| 52 | using FluidState = typename Traits::FluidState; | ||
| 53 | //! Export type of solid state | ||
| 54 | using SolidState = typename Traits::SolidState; | ||
| 55 | //! Export type of solid system | ||
| 56 | using SolidSystem = typename Traits::SolidSystem; | ||
| 57 | //! Export indices | ||
| 58 | using Indices = typename Traits::ModelTraits::Indices; | ||
| 59 | //! Export phase access indices | ||
| 60 | static constexpr int liquidPhaseIdx = 0; | ||
| 61 | static constexpr int gasPhaseIdx = 1; | ||
| 62 | |||
| 63 | /*! | ||
| 64 | * \brief Updates all quantities for a given control volume. | ||
| 65 | * | ||
| 66 | * \param elemSol A vector containing all primary variables connected to the element | ||
| 67 | * \param problem The object specifying the problem which ought to | ||
| 68 | * be simulated | ||
| 69 | * \param element An element which contains part of the control volume | ||
| 70 | * \param scv The sub-control volume | ||
| 71 | */ | ||
| 72 | template<class ElemSol, class Problem, class Element, class Scv> | ||
| 73 | 5291994 | void update(const ElemSol &elemSol, | |
| 74 | const Problem &problem, | ||
| 75 | const Element &element, | ||
| 76 | const Scv& scv) | ||
| 77 | { | ||
| 78 | 5291994 | ParentType::update(elemSol, problem, element, scv); | |
| 79 | |||
| 80 | 5291994 | completeFluidState(elemSol, problem, element, scv, fluidState_, solidState_); | |
| 81 | ////////// | ||
| 82 | // specify the other parameters | ||
| 83 | ////////// | ||
| 84 | |||
| 85 | 10583988 | const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol); | |
| 86 | 10583988 | relativePermeabilityWetting_ = fluidMatrixInteraction.krw(fluidState_.saturation(0)); | |
| 87 | |||
| 88 | // precompute the minimum capillary pressure (entry pressure) | ||
| 89 | // needed to make sure we don't compute unphysical capillary pressures and thus saturations | ||
| 90 | 5291994 | minPc_ = fluidMatrixInteraction.endPointPc(); | |
| 91 | 5291994 | pn_ = problem.nonwettingReferencePressure(); | |
| 92 | //porosity | ||
| 93 | 5291994 | updateSolidVolumeFractions(elemSol, problem, element, scv, solidState_, ParentType::numFluidComponents()); | |
| 94 | 5291994 | EnergyVolVars::updateSolidEnergyParams(elemSol, problem, element, scv, solidState_); | |
| 95 | 10254594 | permeability_ = problem.spatialParams().permeability(element, scv, elemSol); | |
| 96 | 5291994 | EnergyVolVars::updateEffectiveThermalConductivity(); | |
| 97 | |||
| 98 | // Second instance of a parameter cache. | ||
| 99 | // Could be avoided if diffusion coefficients also | ||
| 100 | // became part of the fluid state. | ||
| 101 | typename FluidSystem::ParameterCache paramCache; | ||
| 102 | 5291994 | paramCache.updatePhase(fluidState_, 0); | |
| 103 | |||
| 104 | 5291994 | auto getEffectiveDiffusionCoefficient = [&](int phaseIdx, int compIIdx, int compJIdx) | |
| 105 | { | ||
| 106 | 5291994 | return EffDiffModel::effectiveDiffusionCoefficient(*this, phaseIdx, compIIdx, compJIdx); | |
| 107 | }; | ||
| 108 | |||
| 109 | 5291994 | effectiveDiffCoeff_.update(getEffectiveDiffusionCoefficient); | |
| 110 | |||
| 111 | // calculate the remaining quantities | ||
| 112 | 5291994 | EnergyVolVars::updateSolidEnergyParams(elemSol, problem, element, scv, solidState_); | |
| 113 | 10583988 | permeability_ = problem.spatialParams().permeability(element, scv, elemSol); | |
| 114 | 5291994 | EnergyVolVars::updateEffectiveThermalConductivity(); | |
| 115 | 5291994 | } | |
| 116 | |||
| 117 | /*! | ||
| 118 | * \brief Fills the fluid state according to the primary variables. | ||
| 119 | * | ||
| 120 | * Taking the information from the primary variables, | ||
| 121 | * the fluid state is filled with every information that is | ||
| 122 | * necessary to evaluate the model's local residual. | ||
| 123 | * | ||
| 124 | * \param elemSol A vector containing all primary variables connected to the element | ||
| 125 | * \param problem The problem at hand. | ||
| 126 | * \param element The current element. | ||
| 127 | * \param scv The subcontrol volume. | ||
| 128 | * \param fluidState The fluid state to fill. | ||
| 129 | * \param solidState The solid state to fill. | ||
| 130 | */ | ||
| 131 | template<class ElemSol, class Problem, class Element, class Scv> | ||
| 132 | 5291994 | void completeFluidState(const ElemSol& elemSol, | |
| 133 | const Problem& problem, | ||
| 134 | const Element& element, | ||
| 135 | const Scv& scv, | ||
| 136 | FluidState& fluidState, | ||
| 137 | SolidState& solidState) | ||
| 138 | { | ||
| 139 |
1/2✓ Branch 0 taken 329394 times.
✗ Branch 1 not taken.
|
5291994 | EnergyVolVars::updateTemperature(elemSol, problem, element, scv, fluidState, solidState); |
| 140 | |||
| 141 |
2/4✓ Branch 0 taken 329394 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 329394 times.
✗ Branch 3 not taken.
|
10583988 | const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol); |
| 142 | |||
| 143 |
2/2✓ Branch 0 taken 910817 times.
✓ Branch 1 taken 4381177 times.
|
5291994 | const auto& priVars = elemSol[scv.localDofIndex()]; |
| 144 | |||
| 145 | // set the wetting pressure | ||
| 146 |
4/4✓ Branch 0 taken 910817 times.
✓ Branch 1 taken 4381177 times.
✓ Branch 2 taken 910817 times.
✓ Branch 3 taken 4381177 times.
|
10583988 | fluidState.setPressure(0, priVars[Indices::pressureIdx]); |
| 147 | |||
| 148 | // compute the capillary pressure to compute the saturation | ||
| 149 | // make sure that we the capillary pressure is not smaller than the minimum pc | ||
| 150 | // this would possibly return unphysical values from regularized material laws | ||
| 151 | using std::max; | ||
| 152 |
2/2✓ Branch 0 taken 910817 times.
✓ Branch 1 taken 4381177 times.
|
5291994 | const Scalar pc = max(fluidMatrixInteraction.endPointPc(), |
| 153 |
4/4✓ Branch 0 taken 910817 times.
✓ Branch 1 taken 4381177 times.
✓ Branch 2 taken 910817 times.
✓ Branch 3 taken 4381177 times.
|
10583988 | problem.nonwettingReferencePressure() - fluidState.pressure(0)); |
| 154 | 5291994 | const Scalar sw = fluidMatrixInteraction.sw(pc); | |
| 155 | 5291994 | fluidState.setSaturation(0, sw); | |
| 156 | |||
| 157 | // set the mole/mass fractions | ||
| 158 | if(useMoles) | ||
| 159 | { | ||
| 160 | 5291994 | Scalar sumSecondaryFractions = 0.0; | |
| 161 |
2/2✓ Branch 0 taken 5291994 times.
✓ Branch 1 taken 5291994 times.
|
10583988 | for (int compIdx = 1; compIdx < ParentType::numFluidComponents(); ++compIdx) |
| 162 | { | ||
| 163 | 10583988 | fluidState.setMoleFraction(0, compIdx, priVars[compIdx]); | |
| 164 | 10583988 | sumSecondaryFractions += priVars[compIdx]; | |
| 165 | } | ||
| 166 | 5291994 | fluidState.setMoleFraction(0, 0, 1.0 - sumSecondaryFractions); | |
| 167 | } | ||
| 168 | else | ||
| 169 | { | ||
| 170 | for (int compIdx = 1; compIdx < ParentType::numFluidComponents(); ++compIdx) | ||
| 171 | fluidState.setMassFraction(0, compIdx, priVars[compIdx]); | ||
| 172 | } | ||
| 173 | |||
| 174 | // density and viscosity | ||
| 175 | typename FluidSystem::ParameterCache paramCache; | ||
| 176 | 5291994 | paramCache.updateAll(fluidState); | |
| 177 | 5291994 | fluidState.setDensity(0, FluidSystem::density(fluidState, paramCache, 0)); | |
| 178 | 15875982 | fluidState.setMolarDensity(0, FluidSystem::molarDensity(fluidState, paramCache, 0)); | |
| 179 | 15875982 | fluidState.setViscosity(0, FluidSystem::viscosity(fluidState, paramCache, 0)); | |
| 180 | |||
| 181 | // compute and set the enthalpy | ||
| 182 | 10583988 | fluidState.setEnthalpy(0, EnergyVolVars::enthalpy(fluidState, paramCache, 0)); | |
| 183 | 5291994 | } | |
| 184 | |||
| 185 | /*! | ||
| 186 | * \brief Returns the fluid configuration at the given primary | ||
| 187 | * variables. | ||
| 188 | */ | ||
| 189 | const FluidState &fluidState() const | ||
| 190 | { return fluidState_; } | ||
| 191 | |||
| 192 | /*! | ||
| 193 | * \brief Returns the phase state for the control volume. | ||
| 194 | */ | ||
| 195 | const SolidState &solidState() const | ||
| 196 | { return solidState_; } | ||
| 197 | |||
| 198 | /*! | ||
| 199 | * \brief Returns the average molar mass \f$\mathrm{[kg/mol]}\f$ of the fluid phase. | ||
| 200 | * | ||
| 201 | * \param phaseIdx The phase index | ||
| 202 | */ | ||
| 203 | Scalar averageMolarMass(const int phaseIdx = 0) const | ||
| 204 | { return fluidState_.averageMolarMass(phaseIdx); } | ||
| 205 | |||
| 206 | /*! | ||
| 207 | * \brief Returns the temperature. | ||
| 208 | */ | ||
| 209 | Scalar temperature() const | ||
| 210 | 381584 | { return fluidState_.temperature(); } | |
| 211 | |||
| 212 | /*! | ||
| 213 | * \brief Returns the average porosity [] within the control volume. | ||
| 214 | * | ||
| 215 | * The porosity is defined as the ratio of the pore space to the | ||
| 216 | * total volume, i.e. \f[ \Phi := \frac{V_{pore}}{V_{pore} + V_{rock}} \f] | ||
| 217 | */ | ||
| 218 | Scalar porosity() const | ||
| 219 |
2/8✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 5 taken 173000 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 173000 times.
✗ Branch 9 not taken.
|
63547528 | { return solidState_.porosity(); } |
| 220 | |||
| 221 | /*! | ||
| 222 | * \brief Returns the permeability within the control volume in \f$[m^2]\f$. | ||
| 223 | */ | ||
| 224 | const PermeabilityType& permeability() const | ||
| 225 | ✗ | { return permeability_; } | |
| 226 | |||
| 227 | /*! | ||
| 228 | * \brief Returns the average absolute saturation [] of a given | ||
| 229 | * fluid phase within the finite volume. | ||
| 230 | * | ||
| 231 | * The saturation of a fluid phase is defined as the fraction of | ||
| 232 | * the pore volume filled by it, i.e. | ||
| 233 | * \f[ S_\alpha := \frac{V_\alpha}{V_{pore}} = \phi \frac{V_\alpha}{V} \f] | ||
| 234 | * | ||
| 235 | * \param phaseIdx The index of the fluid phase | ||
| 236 | */ | ||
| 237 | Scalar saturation(const int phaseIdx = 0) const | ||
| 238 |
2/6✗ Branch 0 not taken.
✗ Branch 1 not taken.
✓ Branch 3 taken 173000 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 173000 times.
✗ Branch 7 not taken.
|
63547528 | { return phaseIdx == 0 ? fluidState_.saturation(0) : 1.0-fluidState_.saturation(0); } |
| 239 | |||
| 240 | /*! | ||
| 241 | * \brief Returns the average mass density \f$\mathrm{[kg/m^3]}\f$ of a given | ||
| 242 | * fluid phase within the control volume. | ||
| 243 | * | ||
| 244 | * \param phaseIdx The index of the fluid phase | ||
| 245 | */ | ||
| 246 | Scalar density(const int phaseIdx = 0) const | ||
| 247 |
8/14✓ Branch 0 taken 36767424 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36191424 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 21760 times.
✓ Branch 5 taken 140000 times.
✓ Branch 6 taken 8078264 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 8218264 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 33000 times.
✗ Branch 12 not taken.
✓ Branch 14 taken 33000 times.
✗ Branch 15 not taken.
|
73501408 | { return phaseIdx == 0 ? fluidState_.density(phaseIdx) : 0.0; } |
| 248 | |||
| 249 | /*! | ||
| 250 | * \brief Returns the effective pressure \f$\mathrm{[Pa]}\f$ of a given phase within | ||
| 251 | * the control volume. | ||
| 252 | * | ||
| 253 | * For the nonwetting phase (i.e. the gas phase), we assume | ||
| 254 | * infinite mobility, which implies that the nonwetting phase | ||
| 255 | * pressure is equal to the finite volume's reference pressure | ||
| 256 | * defined by the problem. | ||
| 257 | * | ||
| 258 | * \param phaseIdx The index of the fluid phase | ||
| 259 | */ | ||
| 260 | Scalar pressure(const int phaseIdx = 0) const | ||
| 261 |
2/8✓ Branch 0 taken 36900024 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8100024 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
36900024 | { return phaseIdx == 0 ? fluidState_.pressure(phaseIdx) : pn_; } |
| 262 | |||
| 263 | /*! | ||
| 264 | * \brief Returns the effective mobility \f$\mathrm{[1/(Pa*s)]}\f$ of a given phase within | ||
| 265 | * the control volume. | ||
| 266 | * | ||
| 267 | * The mobility of a fluid phase is defined as the relative | ||
| 268 | * permeability of the phase (given by the chosen material law) | ||
| 269 | * divided by the dynamic viscosity of the fluid, i.e. | ||
| 270 | * \f[ \lambda_\alpha := \frac{k_{r\alpha}}{\mu_\alpha} \f] | ||
| 271 | * | ||
| 272 | * \param phaseIdx The index of the fluid phase | ||
| 273 | */ | ||
| 274 | Scalar mobility(const int phaseIdx = 0) const | ||
| 275 |
12/24✓ Branch 0 taken 2148473 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2148473 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2137951 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2137951 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 8703657 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 8703657 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6319767 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6319767 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 6718577 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 6718577 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 4295023 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 4295023 times.
✗ Branch 23 not taken.
|
121293792 | { return relativePermeability(phaseIdx)/fluidState_.viscosity(phaseIdx); } |
| 276 | |||
| 277 | /*! | ||
| 278 | * \brief Returns the dynamic viscosity \f$\mathrm{[Pa*s]}\f$ of a given phase within | ||
| 279 | * the control volume. | ||
| 280 | * | ||
| 281 | * \param phaseIdx The index of the fluid phase | ||
| 282 | * \note The nonwetting phase is infinitely mobile | ||
| 283 | */ | ||
| 284 | Scalar viscosity(const int phaseIdx = 0) const | ||
| 285 | { return phaseIdx == 0 ? fluidState_.viscosity(0) : 0.0; } | ||
| 286 | |||
| 287 | /*! | ||
| 288 | * \brief Returns relative permeability [-] of a given phase within | ||
| 289 | * the control volume. | ||
| 290 | * | ||
| 291 | * \param phaseIdx The index of the fluid phase | ||
| 292 | */ | ||
| 293 | ✗ | Scalar relativePermeability(const int phaseIdx = 0) const | |
| 294 |
14/32✓ Branch 0 taken 2148473 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2148473 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2137951 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2137951 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1985080 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 8703657 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 8743321 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6319767 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 4295023 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 1984962 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 6718577 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 6706253 times.
✗ Branch 23 not taken.
✓ Branch 24 taken 4295023 times.
✗ Branch 25 not taken.
✓ Branch 26 taken 2322385 times.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
|
60370296 | { return phaseIdx == 0 ? relativePermeabilityWetting_ : 1.0; } |
| 295 | |||
| 296 | /*! | ||
| 297 | * \brief Returns the effective capillary pressure \f$\mathrm{[Pa]}\f$ within the | ||
| 298 | * control volume. | ||
| 299 | * | ||
| 300 | * The capillary pressure is defined as the difference in | ||
| 301 | * pressures of the nonwetting and the wetting phase, i.e. | ||
| 302 | * \f[ p_c = p_n - p_w \f] | ||
| 303 | * | ||
| 304 | * \note Capillary pressures are always larger than the entry pressure | ||
| 305 | * This regularization doesn't affect the residual in which pc is not needed. | ||
| 306 | */ | ||
| 307 | Scalar capillaryPressure() const | ||
| 308 | { | ||
| 309 | using std::max; | ||
| 310 |
4/8✓ Branch 0 taken 33834 times.
✓ Branch 1 taken 156958 times.
✓ Branch 2 taken 33834 times.
✓ Branch 3 taken 156958 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
381584 | return max(minPc_, pn_ - fluidState_.pressure(0)); |
| 311 | } | ||
| 312 | |||
| 313 | /*! | ||
| 314 | * \brief Returns the pressureHead \f$\mathrm{[cm]}\f$ of a given phase within | ||
| 315 | * the control volume. | ||
| 316 | * | ||
| 317 | * For the nonwetting phase (i.e. the gas phase), we assume | ||
| 318 | * infinite mobility, which implies that the nonwetting phase | ||
| 319 | * pressure is equal to the finite volume's reference pressure | ||
| 320 | * defined by the problem. | ||
| 321 | * | ||
| 322 | * \param phaseIdx The index of the fluid phase | ||
| 323 | * \note this function is here as a convenience to the user to not have to | ||
| 324 | * manually do a conversion. It is not correct if the density is not constant | ||
| 325 | * or the gravity different | ||
| 326 | */ | ||
| 327 | Scalar pressureHead(const int phaseIdx = 0) const | ||
| 328 | 572376 | { return 100.0 *(pressure(phaseIdx) - pn_)/density(phaseIdx)/9.81; } | |
| 329 | |||
| 330 | /*! | ||
| 331 | * \brief Returns the water content | ||
| 332 | * fluid phase within the finite volume. | ||
| 333 | * | ||
| 334 | * The water content is defined as the fraction of | ||
| 335 | * the saturation divided by the porosity | ||
| 336 | |||
| 337 | * \param phaseIdx The index of the fluid phase | ||
| 338 | * \note this function is here as a convenience to the user to not have to | ||
| 339 | * manually do a conversion. | ||
| 340 | */ | ||
| 341 | Scalar waterContent(const int phaseIdx = 0) const | ||
| 342 | 572376 | { return saturation(phaseIdx) * solidState_.porosity(); } | |
| 343 | |||
| 344 | /*! | ||
| 345 | * \brief Returns the molar density \f$\mathrm{[mol/m^3]}\f$ the of the fluid phase. | ||
| 346 | * | ||
| 347 | * We always forward to the fluid state with the phaseIdx property (see class description). | ||
| 348 | */ | ||
| 349 | Scalar molarDensity(const int phaseIdx = 0) const | ||
| 350 |
9/24✓ Branch 0 taken 8703657 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8703657 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6319767 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6319767 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3970042 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 8703657 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 8730997 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6319767 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 2322385 times.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
|
123231264 | { return phaseIdx == 0 ? this->fluidState_.molarDensity(phaseIdx) : 0.0; } |
| 351 | |||
| 352 | /*! | ||
| 353 | * \brief Returns the mole fraction \f$\mathrm{[mol/mol]}\f$ of a component in the phase. | ||
| 354 | * | ||
| 355 | * \param phaseIdx The index of the phase. | ||
| 356 | * \param compIdx The index of the component. | ||
| 357 | * | ||
| 358 | * We always forward to the fluid state with the phaseIdx property (see class description). | ||
| 359 | */ | ||
| 360 | Scalar moleFraction(const int phaseIdx, const int compIdx) const | ||
| 361 |
4/14✓ Branch 0 taken 8703657 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8703657 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6319767 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6319767 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
61615632 | { return phaseIdx == 0 ? this->fluidState_.moleFraction(phaseIdx, compIdx) : 0.0; } |
| 362 | |||
| 363 | /*! | ||
| 364 | * \brief Returns the mass fraction \f$\mathrm{[kg/kg]}\f$ of a component in the phase. | ||
| 365 | * | ||
| 366 | * \param phaseIdx The index of the phase. | ||
| 367 | * \param compIdx The index of the component | ||
| 368 | * | ||
| 369 | * We always forward to the fluid state with the phaseIdx property (see class description). | ||
| 370 | */ | ||
| 371 | Scalar massFraction(const int phaseIdx, const int compIdx) const | ||
| 372 |
8/16✓ Branch 0 taken 36191424 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36191424 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7967424 times.
✓ Branch 5 taken 140000 times.
✓ Branch 6 taken 7967424 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 140000 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✓ Branch 13 taken 64980 times.
✗ Branch 14 not taken.
✓ Branch 16 taken 33000 times.
✗ Branch 17 not taken.
|
80555252 | { return phaseIdx == 0 ? this->fluidState_.massFraction(phaseIdx, compIdx) : 0.0; } |
| 373 | |||
| 374 | /*! | ||
| 375 | * \brief Returns the concentration \f$\mathrm{[mol/m^3]}\f$ of a component in the phase. | ||
| 376 | * | ||
| 377 | * \param phaseIdx The index of the phase. | ||
| 378 | * \param compIdx The index of the component | ||
| 379 | * | ||
| 380 | * We always forward to the fluid state with the phaseIdx property (see class description). | ||
| 381 | */ | ||
| 382 | Scalar molarity(const int phaseIdx, const int compIdx) const | ||
| 383 | { return phaseIdx == 0 ? this->fluidState_.molarity(phaseIdx, compIdx) : 0.0; } | ||
| 384 | |||
| 385 | /*! | ||
| 386 | * \brief Returns the binary diffusion coefficients for a phase in \f$[m^2/s]\f$. | ||
| 387 | */ | ||
| 388 | ✗ | Scalar diffusionCoefficient(int phaseIdx, int compIIdx, int compJIdx) const | |
| 389 | { | ||
| 390 | typename FluidSystem::ParameterCache paramCache; | ||
| 391 | ✗ | paramCache.updatePhase(fluidState_, phaseIdx); | |
| 392 | ✗ | return FluidSystem::binaryDiffusionCoefficient(fluidState_, paramCache, phaseIdx, compIIdx, compJIdx); | |
| 393 | } | ||
| 394 | |||
| 395 | /*! | ||
| 396 | * \brief Returns the effective diffusion coefficients for a phase in \f$[m^2/s]\f$. | ||
| 397 | */ | ||
| 398 | Scalar effectiveDiffusionCoefficient(int phaseIdx, int compIIdx, int compJIdx) const | ||
| 399 | 15571516 | { return effectiveDiffCoeff_(phaseIdx, compIIdx, compJIdx); } | |
| 400 | |||
| 401 | protected: | ||
| 402 | FluidState fluidState_; //!< the fluid state | ||
| 403 | |||
| 404 | private: | ||
| 405 | // Effective diffusion coefficients for the phases | ||
| 406 | DiffusionCoefficients effectiveDiffCoeff_; | ||
| 407 | |||
| 408 | Scalar relativePermeabilityWetting_; // the relative permeability of the wetting phase | ||
| 409 | SolidState solidState_; | ||
| 410 | PermeabilityType permeability_; // the intrinsic permeability | ||
| 411 | Scalar pn_; // the reference nonwetting pressure | ||
| 412 | Scalar minPc_; // the minimum capillary pressure (entry pressure) | ||
| 413 | }; | ||
| 414 | |||
| 415 | } // end namespace Dumux | ||
| 416 | |||
| 417 | #endif | ||
| 418 |