My Project
Loading...
Searching...
No Matches
EclMultiplexerMaterial.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*/
27#ifndef OPM_ECL_MULTIPLEXER_MATERIAL_HPP
28#define OPM_ECL_MULTIPLEXER_MATERIAL_HPP
29
32#include "EclStone1Material.hpp"
33#include "EclStone2Material.hpp"
35
36#include <opm/common/TimingMacros.hpp>
37
38#include <algorithm>
39#include <stdexcept>
40
41namespace Opm {
42
49template <class TraitsT,
50 class GasOilMaterialLawT,
51 class OilWaterMaterialLawT,
52 class GasWaterMaterialLawT,
53 class ParamsT = EclMultiplexerMaterialParams<TraitsT,
54 GasOilMaterialLawT,
55 OilWaterMaterialLawT,
56 GasWaterMaterialLawT> >
57class EclMultiplexerMaterial : public TraitsT
58{
59public:
60 using GasOilMaterialLaw = GasOilMaterialLawT;
61 using OilWaterMaterialLaw = OilWaterMaterialLawT;
62 using GasWaterMaterialLaw = GasWaterMaterialLawT;
63
68
69 // some safety checks
70 static_assert(TraitsT::numPhases == 3,
71 "The number of phases considered by this capillary pressure "
72 "law is always three!");
73 static_assert(GasOilMaterialLaw::numPhases == 2,
74 "The number of phases considered by the gas-oil capillary "
75 "pressure law must be two!");
76 static_assert(OilWaterMaterialLaw::numPhases == 2,
77 "The number of phases considered by the oil-water capillary "
78 "pressure law must be two!");
79 static_assert(GasWaterMaterialLaw::numPhases == 2,
80 "The number of phases considered by the gas-water capillary "
81 "pressure law must be two!");
82 static_assert(std::is_same<typename GasOilMaterialLaw::Scalar,
83 typename OilWaterMaterialLaw::Scalar>::value,
84 "The two two-phase capillary pressure laws must use the same "
85 "type of floating point values.");
86
87 using Traits = TraitsT;
88 using Params = ParamsT;
89 using Scalar = typename Traits::Scalar;
90
91 static constexpr int numPhases = 3;
92 static constexpr int waterPhaseIdx = Traits::wettingPhaseIdx;
93 static constexpr int oilPhaseIdx = Traits::nonWettingPhaseIdx;
94 static constexpr int gasPhaseIdx = Traits::gasPhaseIdx;
95
98 static constexpr bool implementsTwoPhaseApi = false;
99
102 static constexpr bool implementsTwoPhaseSatApi = false;
103
106 static constexpr bool isSaturationDependent = true;
107
110 static constexpr bool isPressureDependent = false;
111
114 static constexpr bool isTemperatureDependent = false;
115
118 static constexpr bool isCompositionDependent = false;
119
134 template <class ContainerT, class FluidState>
135 static void capillaryPressures(ContainerT& values,
136 const Params& params,
137 const FluidState& fluidState)
138 {
139 OPM_TIMEFUNCTION_LOCAL();
140 switch (params.approach()) {
141 case EclMultiplexerApproach::Stone1:
143 params.template getRealParams<EclMultiplexerApproach::Stone1>(),
144 fluidState);
145 break;
146
147 case EclMultiplexerApproach::Stone2:
149 params.template getRealParams<EclMultiplexerApproach::Stone2>(),
150 fluidState);
151 break;
152
153 case EclMultiplexerApproach::Default:
155 params.template getRealParams<EclMultiplexerApproach::Default>(),
156 fluidState);
157 break;
158
159 case EclMultiplexerApproach::TwoPhase:
161 params.template getRealParams<EclMultiplexerApproach::TwoPhase>(),
162 fluidState);
163 break;
164
165 case EclMultiplexerApproach::OnePhase:
166 values[0] = 0.0;
167 break;
168 }
169 }
170
171 /*
172 * Hysteresis parameters for oil-water
173 * @see EclHysteresisTwoPhaseLawParams::soMax(...)
174 * @see EclHysteresisTwoPhaseLawParams::swMax(...)
175 * @see EclHysteresisTwoPhaseLawParams::swMin(...)
176 * \param params Parameters
177 */
178 static void oilWaterHysteresisParams(Scalar& soMax,
179 Scalar& swMax,
180 Scalar& swMin,
181 const Params& params)
182 {
183 OPM_TIMEFUNCTION_LOCAL();
184 switch (params.approach()) {
185 case EclMultiplexerApproach::Stone1:
186 Stone1Material::oilWaterHysteresisParams(soMax, swMax, swMin,
187 params.template getRealParams<EclMultiplexerApproach::Stone1>());
188 break;
189
190 case EclMultiplexerApproach::Stone2:
191 Stone2Material::oilWaterHysteresisParams(soMax, swMax, swMin,
192 params.template getRealParams<EclMultiplexerApproach::Stone2>());
193 break;
194
195 case EclMultiplexerApproach::Default:
196 DefaultMaterial::oilWaterHysteresisParams(soMax, swMax, swMin,
197 params.template getRealParams<EclMultiplexerApproach::Default>());
198 break;
199
200 case EclMultiplexerApproach::TwoPhase:
201 TwoPhaseMaterial::oilWaterHysteresisParams(soMax, swMax, swMin,
202 params.template getRealParams<EclMultiplexerApproach::TwoPhase>());
203 break;
204
205 case EclMultiplexerApproach::OnePhase:
206 // Do nothing.
207 break;
208 }
209 }
210
211 /*
212 * Hysteresis parameters for oil-water
213 * @see EclHysteresisTwoPhaseLawParams::soMax(...)
214 * @see EclHysteresisTwoPhaseLawParams::swMax(...)
215 * @see EclHysteresisTwoPhaseLawParams::swMin(...)
216 * \param params Parameters
217 */
218 static void setOilWaterHysteresisParams(const Scalar& soMax,
219 const Scalar& swMax,
220 const Scalar& swMin,
221 Params& params)
222 {
223 OPM_TIMEFUNCTION_LOCAL();
224 switch (params.approach()) {
225 case EclMultiplexerApproach::Stone1:
226 Stone1Material::setOilWaterHysteresisParams(soMax, swMax, swMin,
227 params.template getRealParams<EclMultiplexerApproach::Stone1>());
228 break;
229
230 case EclMultiplexerApproach::Stone2:
231 Stone2Material::setOilWaterHysteresisParams(soMax, swMax, swMin,
232 params.template getRealParams<EclMultiplexerApproach::Stone2>());
233 break;
234
235 case EclMultiplexerApproach::Default:
236 DefaultMaterial::setOilWaterHysteresisParams(soMax, swMax, swMin,
237 params.template getRealParams<EclMultiplexerApproach::Default>());
238 break;
239
240 case EclMultiplexerApproach::TwoPhase:
241 TwoPhaseMaterial::setOilWaterHysteresisParams(soMax, swMax, swMin,
242 params.template getRealParams<EclMultiplexerApproach::TwoPhase>());
243 break;
244
245 case EclMultiplexerApproach::OnePhase:
246 // Do nothing.
247 break;
248 }
249 }
250
251 /*
252 * Hysteresis parameters for gas-oil
253 * @see EclHysteresisTwoPhaseLawParams::sgmax(...)
254 * @see EclHysteresisTwoPhaseLawParams::shmax(...)
255 * @see EclHysteresisTwoPhaseLawParams::somin(...)
256 * \param params Parameters
257 */
258 static void gasOilHysteresisParams(Scalar& sgmax,
259 Scalar& shmax,
260 Scalar& somin,
261 const Params& params)
262 {
263 OPM_TIMEFUNCTION_LOCAL();
264 switch (params.approach()) {
265 case EclMultiplexerApproach::Stone1:
266 Stone1Material::gasOilHysteresisParams(sgmax, shmax, somin,
267 params.template getRealParams<EclMultiplexerApproach::Stone1>());
268 break;
269
270 case EclMultiplexerApproach::Stone2:
271 Stone2Material::gasOilHysteresisParams(sgmax, shmax, somin,
272 params.template getRealParams<EclMultiplexerApproach::Stone2>());
273 break;
274
275 case EclMultiplexerApproach::Default:
276 DefaultMaterial::gasOilHysteresisParams(sgmax, shmax, somin,
277 params.template getRealParams<EclMultiplexerApproach::Default>());
278 break;
279
280 case EclMultiplexerApproach::TwoPhase:
281 TwoPhaseMaterial::gasOilHysteresisParams(sgmax, shmax, somin,
282 params.template getRealParams<EclMultiplexerApproach::TwoPhase>());
283 break;
284
285 case EclMultiplexerApproach::OnePhase:
286 // Do nothing.
287 break;
288 }
289 }
290
291 static Scalar trappedGasSaturation(const Params& params, bool maximumTrapping)
292 {
293 OPM_TIMEFUNCTION_LOCAL();
294 switch (params.approach()) {
295 case EclMultiplexerApproach::Stone1:
296 return Stone1Material::trappedGasSaturation(params.template getRealParams<EclMultiplexerApproach::Stone1>(), maximumTrapping);
297 case EclMultiplexerApproach::Stone2:
298 return Stone2Material::trappedGasSaturation(params.template getRealParams<EclMultiplexerApproach::Stone2>(), maximumTrapping);
299 case EclMultiplexerApproach::Default:
300 return DefaultMaterial::trappedGasSaturation(params.template getRealParams<EclMultiplexerApproach::Default>(), maximumTrapping);
301 case EclMultiplexerApproach::TwoPhase:
302 return TwoPhaseMaterial::trappedGasSaturation(params.template getRealParams<EclMultiplexerApproach::TwoPhase>(), maximumTrapping);
303 case EclMultiplexerApproach::OnePhase:
304 return 0.0;
305 }
306 return 0.0;
307 }
308
309 static Scalar strandedGasSaturation(const Params& params, Scalar Sg, Scalar Kg)
310 {
311 OPM_TIMEFUNCTION_LOCAL();
312 switch (params.approach()) {
313 case EclMultiplexerApproach::Stone1:
314 return Stone1Material::strandedGasSaturation(params.template getRealParams<EclMultiplexerApproach::Stone1>(), Sg, Kg);
315 case EclMultiplexerApproach::Stone2:
316 return Stone2Material::strandedGasSaturation(params.template getRealParams<EclMultiplexerApproach::Stone2>(), Sg, Kg);
317 case EclMultiplexerApproach::Default:
318 return DefaultMaterial::strandedGasSaturation(params.template getRealParams<EclMultiplexerApproach::Default>(), Sg, Kg);
319 case EclMultiplexerApproach::TwoPhase:
320 return TwoPhaseMaterial::strandedGasSaturation(params.template getRealParams<EclMultiplexerApproach::TwoPhase>(), Sg, Kg);
321 case EclMultiplexerApproach::OnePhase:
322 return 0.0;
323 }
324 return 0.0;
325 }
326
327 static Scalar trappedOilSaturation(const Params& params, bool maximumTrapping)
328 {
329 OPM_TIMEFUNCTION_LOCAL();
330 switch (params.approach()) {
331 case EclMultiplexerApproach::Stone1:
332 return Stone1Material::trappedOilSaturation(params.template getRealParams<EclMultiplexerApproach::Stone1>(), maximumTrapping);
333 case EclMultiplexerApproach::Stone2:
334 return Stone2Material::trappedOilSaturation(params.template getRealParams<EclMultiplexerApproach::Stone2>(), maximumTrapping);
335 case EclMultiplexerApproach::Default:
336 return DefaultMaterial::trappedOilSaturation(params.template getRealParams<EclMultiplexerApproach::Default>(), maximumTrapping);
337 case EclMultiplexerApproach::TwoPhase:
338 return TwoPhaseMaterial::trappedOilSaturation(params.template getRealParams<EclMultiplexerApproach::TwoPhase>(), maximumTrapping);
339 case EclMultiplexerApproach::OnePhase:
340 return 0.0;
341 }
342 return 0.0;
343 }
344
345 static Scalar trappedWaterSaturation(const Params& params)
346 {
347 OPM_TIMEFUNCTION_LOCAL();
348 switch (params.approach()) {
349 case EclMultiplexerApproach::Stone1:
350 return Stone1Material::trappedWaterSaturation(params.template getRealParams<EclMultiplexerApproach::Stone1>());
351 case EclMultiplexerApproach::Stone2:
352 return Stone2Material::trappedWaterSaturation(params.template getRealParams<EclMultiplexerApproach::Stone2>());
353 case EclMultiplexerApproach::Default:
354 return DefaultMaterial::trappedWaterSaturation(params.template getRealParams<EclMultiplexerApproach::Default>());
355 case EclMultiplexerApproach::TwoPhase:
356 return TwoPhaseMaterial::trappedWaterSaturation(params.template getRealParams<EclMultiplexerApproach::TwoPhase>());
357 case EclMultiplexerApproach::OnePhase:
358 return 0.0;
359 }
360 return 0.0;
361 }
362 /*
363 * Hysteresis parameters for gas-oil
364 * @see EclHysteresisTwoPhaseLawParams::sgmax(...)
365 * @see EclHysteresisTwoPhaseLawParams::shmax(...)
366 * @see EclHysteresisTwoPhaseLawParams::somin(...)
367 * \param params Parameters
368 */
369 static void setGasOilHysteresisParams(const Scalar& sgmax,
370 const Scalar& shmax,
371 const Scalar& somin,
372 Params& params)
373 {
374 OPM_TIMEFUNCTION_LOCAL();
375 switch (params.approach()) {
376 case EclMultiplexerApproach::Stone1:
377 Stone1Material::setGasOilHysteresisParams(sgmax, shmax, somin,
378 params.template getRealParams<EclMultiplexerApproach::Stone1>());
379 break;
380
381 case EclMultiplexerApproach::Stone2:
382 Stone2Material::setGasOilHysteresisParams(sgmax, shmax, somin,
383 params.template getRealParams<EclMultiplexerApproach::Stone2>());
384 break;
385
386 case EclMultiplexerApproach::Default:
387 DefaultMaterial::setGasOilHysteresisParams(sgmax, shmax, somin,
388 params.template getRealParams<EclMultiplexerApproach::Default>());
389 break;
390
391 case EclMultiplexerApproach::TwoPhase:
392 TwoPhaseMaterial::setGasOilHysteresisParams(sgmax, shmax, somin,
393 params.template getRealParams<EclMultiplexerApproach::TwoPhase>());
394 break;
395
396 case EclMultiplexerApproach::OnePhase:
397 // Do nothing.
398 break;
399 }
400 }
401
411 template <class FluidState, class Evaluation = typename FluidState::Scalar>
412 static Evaluation pcgn(const Params& /* params */,
413 const FluidState& /* fs */)
414 {
415 throw std::logic_error("Not implemented: pcgn()");
416 }
417
427 template <class FluidState, class Evaluation = typename FluidState::Scalar>
428 static Evaluation pcnw(const Params& /* params */,
429 const FluidState& /* fs */)
430 {
431 throw std::logic_error("Not implemented: pcnw()");
432 }
433
437 template <class ContainerT, class FluidState>
438 static void saturations(ContainerT& /* values */,
439 const Params& /* params */,
440 const FluidState& /* fs */)
441 {
442 throw std::logic_error("Not implemented: saturations()");
443 }
444
448 template <class FluidState, class Evaluation = typename FluidState::Scalar>
449 static Evaluation Sg(const Params& /* params */,
450 const FluidState& /* fluidState */)
451 {
452 throw std::logic_error("Not implemented: Sg()");
453 }
454
458 template <class FluidState, class Evaluation = typename FluidState::Scalar>
459 static Evaluation Sn(const Params& /* params */,
460 const FluidState& /* fluidState */)
461 {
462 throw std::logic_error("Not implemented: Sn()");
463 }
464
468 template <class FluidState, class Evaluation = typename FluidState::Scalar>
469 static Evaluation Sw(const Params& /* params */,
470 const FluidState& /* fluidState */)
471 {
472 throw std::logic_error("Not implemented: Sw()");
473 }
474
490 template <class ContainerT, class FluidState>
491 static void relativePermeabilities(ContainerT& values,
492 const Params& params,
493 const FluidState& fluidState)
494 {
495 OPM_TIMEFUNCTION_LOCAL();
496 switch (params.approach()) {
497 case EclMultiplexerApproach::Stone1:
499 params.template getRealParams<EclMultiplexerApproach::Stone1>(),
500 fluidState);
501 break;
502
503 case EclMultiplexerApproach::Stone2:
505 params.template getRealParams<EclMultiplexerApproach::Stone2>(),
506 fluidState);
507 break;
508
509 case EclMultiplexerApproach::Default:
511 params.template getRealParams<EclMultiplexerApproach::Default>(),
512 fluidState);
513 break;
514
515 case EclMultiplexerApproach::TwoPhase:
517 params.template getRealParams<EclMultiplexerApproach::TwoPhase>(),
518 fluidState);
519 break;
520
521 case EclMultiplexerApproach::OnePhase:
522 values[0] = 1.0;
523 break;
524
525 default:
526 throw std::logic_error("Not implemented: relativePermeabilities() option for unknown EclMultiplexerApproach (="
527 + std::to_string(static_cast<int>(params.approach())) + ")");
528 }
529 }
530
534 template <class Evaluation, class FluidState>
535 static Evaluation relpermOilInOilGasSystem(const Params& params,
536 const FluidState& fluidState)
537 {
538 OPM_TIMEFUNCTION_LOCAL();
539 switch (params.approach()) {
540 case EclMultiplexerApproach::Stone1:
541 return Stone1Material::template relpermOilInOilGasSystem<Evaluation>
542 (params.template getRealParams<EclMultiplexerApproach::Stone1>(),
543 fluidState);
544
545 case EclMultiplexerApproach::Stone2:
546 return Stone2Material::template relpermOilInOilGasSystem<Evaluation>
547 (params.template getRealParams<EclMultiplexerApproach::Stone2>(),
548 fluidState);
549
550 case EclMultiplexerApproach::Default:
551 return DefaultMaterial::template relpermOilInOilGasSystem<Evaluation>
552 (params.template getRealParams<EclMultiplexerApproach::Default>(),
553 fluidState);
554
555 default:
556 throw std::logic_error {
557 "relpermOilInOilGasSystem() is specific to three phases"
558 };
559 }
560 }
561
565 template <class Evaluation, class FluidState>
566 static Evaluation relpermOilInOilWaterSystem(const Params& params,
567 const FluidState& fluidState)
568 {
569 OPM_TIMEFUNCTION_LOCAL();
570 switch (params.approach()) {
571 case EclMultiplexerApproach::Stone1:
572 return Stone1Material::template relpermOilInOilWaterSystem<Evaluation>
573 (params.template getRealParams<EclMultiplexerApproach::Stone1>(),
574 fluidState);
575
576 case EclMultiplexerApproach::Stone2:
577 return Stone2Material::template relpermOilInOilWaterSystem<Evaluation>
578 (params.template getRealParams<EclMultiplexerApproach::Stone2>(),
579 fluidState);
580
581 case EclMultiplexerApproach::Default:
582 return DefaultMaterial::template relpermOilInOilWaterSystem<Evaluation>
583 (params.template getRealParams<EclMultiplexerApproach::Default>(),
584 fluidState);
585
586 default:
587 throw std::logic_error {
588 "relpermOilInOilWaterSystem() is specific to three phases"
589 };
590 }
591 }
592
596 template <class FluidState, class Evaluation = typename FluidState::Scalar>
597 static Evaluation krg(const Params& /* params */,
598 const FluidState& /* fluidState */)
599 {
600 throw std::logic_error("Not implemented: krg()");
601 }
602
606 template <class FluidState, class Evaluation = typename FluidState::Scalar>
607 static Evaluation krw(const Params& /* params */,
608 const FluidState& /* fluidState */)
609 {
610 throw std::logic_error("Not implemented: krw()");
611 }
612
616 template <class FluidState, class Evaluation = typename FluidState::Scalar>
617 static Evaluation krn(const Params& /* params */,
618 const FluidState& /* fluidState */)
619 {
620 throw std::logic_error("Not implemented: krn()");
621 }
622
623
631 template <class FluidState>
632 static bool updateHysteresis(Params& params, const FluidState& fluidState)
633 {
634 OPM_TIMEFUNCTION_LOCAL();
635 switch (params.approach()) {
636 case EclMultiplexerApproach::Stone1:
637 return Stone1Material::updateHysteresis(params.template getRealParams<EclMultiplexerApproach::Stone1>(),
638 fluidState);
639 break;
640
641 case EclMultiplexerApproach::Stone2:
642 return Stone2Material::updateHysteresis(params.template getRealParams<EclMultiplexerApproach::Stone2>(),
643 fluidState);
644 break;
645
646 case EclMultiplexerApproach::Default:
647 return DefaultMaterial::updateHysteresis(params.template getRealParams<EclMultiplexerApproach::Default>(),
648 fluidState);
649 break;
650
651 case EclMultiplexerApproach::TwoPhase:
652 return TwoPhaseMaterial::updateHysteresis(params.template getRealParams<EclMultiplexerApproach::TwoPhase>(),
653 fluidState);
654 break;
655 case EclMultiplexerApproach::OnePhase:
656 return false;
657 break;
658 }
659 return false;
660 }
661};
662
663} // namespace Opm
664
665#endif
Implements the default three phase capillary pressure law used by the ECLipse simulator.
Multiplexer implementation for the parameters required by the multiplexed three-phase material law.
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
Implements a multiplexer class that provides ECL saturation functions for twophase simulations.
Implements the default three phase capillary pressure law used by the ECLipse simulator.
Definition EclDefaultMaterial.hpp:62
static void capillaryPressures(ContainerT &values, const Params &params, const FluidState &state)
Implements the default three phase capillary pressure law used by the ECLipse simulator.
Definition EclDefaultMaterial.hpp:137
static bool updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition EclDefaultMaterial.hpp:461
static void relativePermeabilities(ContainerT &values, const Params &params, const FluidState &fluidState)
The relative permeability of all phases.
Definition EclDefaultMaterial.hpp:341
Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLi...
Definition EclMultiplexerMaterial.hpp:58
static void capillaryPressures(ContainerT &values, const Params &params, const FluidState &fluidState)
Implements the multiplexer three phase capillary pressure law used by the ECLipse simulator.
Definition EclMultiplexerMaterial.hpp:135
static Evaluation relpermOilInOilWaterSystem(const Params &params, const FluidState &fluidState)
The relative permeability of oil in oil/water system.
Definition EclMultiplexerMaterial.hpp:566
static Evaluation krw(const Params &, const FluidState &)
The relative permeability of the wetting phase.
Definition EclMultiplexerMaterial.hpp:607
static Evaluation Sg(const Params &, const FluidState &)
The saturation of the gas phase.
Definition EclMultiplexerMaterial.hpp:449
static Evaluation relpermOilInOilGasSystem(const Params &params, const FluidState &fluidState)
The relative permeability of oil in oil/gas system.
Definition EclMultiplexerMaterial.hpp:535
static Evaluation pcgn(const Params &, const FluidState &)
Capillary pressure between the gas and the non-wetting liquid (i.e., oil) phase.
Definition EclMultiplexerMaterial.hpp:412
static Evaluation pcnw(const Params &, const FluidState &)
Capillary pressure between the non-wetting liquid (i.e., oil) and the wetting liquid (i....
Definition EclMultiplexerMaterial.hpp:428
static constexpr bool isPressureDependent
Specify whether the quantities defined by this material law are dependent on the absolute pressure.
Definition EclMultiplexerMaterial.hpp:110
static constexpr bool implementsTwoPhaseSatApi
Specify whether this material law implements the two-phase convenience API which only depends on the ...
Definition EclMultiplexerMaterial.hpp:102
static constexpr bool isSaturationDependent
Specify whether the quantities defined by this material law are saturation dependent.
Definition EclMultiplexerMaterial.hpp:106
static constexpr bool isTemperatureDependent
Specify whether the quantities defined by this material law are temperature dependent.
Definition EclMultiplexerMaterial.hpp:114
static constexpr bool implementsTwoPhaseApi
Specify whether this material law implements the two-phase convenience API.
Definition EclMultiplexerMaterial.hpp:98
static void relativePermeabilities(ContainerT &values, const Params &params, const FluidState &fluidState)
The relative permeability of all phases.
Definition EclMultiplexerMaterial.hpp:491
static Evaluation Sn(const Params &, const FluidState &)
The saturation of the non-wetting (i.e., oil) phase.
Definition EclMultiplexerMaterial.hpp:459
static Evaluation krg(const Params &, const FluidState &)
The relative permeability of the gas phase.
Definition EclMultiplexerMaterial.hpp:597
static constexpr bool isCompositionDependent
Specify whether the quantities defined by this material law are dependent on the phase composition.
Definition EclMultiplexerMaterial.hpp:118
static void saturations(ContainerT &, const Params &, const FluidState &)
The inverse of the capillary pressure.
Definition EclMultiplexerMaterial.hpp:438
static Evaluation krn(const Params &, const FluidState &)
The relative permeability of the non-wetting (i.e., oil) phase.
Definition EclMultiplexerMaterial.hpp:617
static Evaluation Sw(const Params &, const FluidState &)
The saturation of the wetting (i.e., water) phase.
Definition EclMultiplexerMaterial.hpp:469
static bool updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition EclMultiplexerMaterial.hpp:632
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
Definition EclStone1Material.hpp:60
static void relativePermeabilities(ContainerT &values, const Params &params, const FluidState &fluidState)
The relative permeability of all phases.
Definition EclStone1Material.hpp:339
static void capillaryPressures(ContainerT &values, const Params &params, const FluidState &state)
Implements the default three phase capillary pressure law used by the ECLipse simulator.
Definition EclStone1Material.hpp:135
static bool updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition EclStone1Material.hpp:446
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
Definition EclStone2Material.hpp:61
static bool updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition EclStone2Material.hpp:431
static void capillaryPressures(ContainerT &values, const Params &params, const FluidState &state)
Implements the default three phase capillary pressure law used by the ECLipse simulator.
Definition EclStone2Material.hpp:136
static void relativePermeabilities(ContainerT &values, const Params &params, const FluidState &fluidState)
The relative permeability of all phases.
Definition EclStone2Material.hpp:341
Implements a multiplexer class that provides ECL saturation functions for twophase simulations.
Definition EclTwoPhaseMaterial.hpp:57
static void relativePermeabilities(ContainerT &values, const Params &params, const FluidState &fluidState)
The relative permeability of all phases.
Definition EclTwoPhaseMaterial.hpp:375
static bool updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition EclTwoPhaseMaterial.hpp:452
static void capillaryPressures(ContainerT &values, const Params &params, const FluidState &fluidState)
Implements the multiplexer three phase capillary pressure law used by the ECLipse simulator.
Definition EclTwoPhaseMaterial.hpp:145
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30