Loading...
Searching...
No Matches
EclMultiplexerMaterial.hpp
Go to the documentation of this file.
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
Consult the COPYING file in the top-level source directory of this
module for the precise wording of the license and the list of
copyright holders.
*/
#ifndef OPM_ECL_MULTIPLEXER_MATERIAL_HPP
#define OPM_ECL_MULTIPLEXER_MATERIAL_HPP
#include "EclMultiplexerMaterialParams.hpp"
#include "EclDefaultMaterial.hpp"
#include "EclStone1Material.hpp"
#include "EclStone2Material.hpp"
#include "EclTwoPhaseMaterial.hpp"
#include <opm/common/TimingMacros.hpp>
#include <algorithm>
#include <stdexcept>
namespace Opm {
#define OPM_ECL_MULTIPLEXER_MATERIAL_CALL(codeToCall, onePhaseCode) \
switch (params.approach()) { \
case EclMultiplexerApproach::Stone1: { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Stone1; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = Stone1Material; \
codeToCall; \
break; \
} \
case EclMultiplexerApproach::Stone2: { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Stone2; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = Stone2Material; \
codeToCall; \
break; \
} \
case EclMultiplexerApproach::Default: { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Default; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = DefaultMaterial; \
codeToCall; \
break; \
} \
case EclMultiplexerApproach::TwoPhase: { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::TwoPhase; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = TwoPhaseMaterial; \
codeToCall; \
break; \
} \
case EclMultiplexerApproach::OnePhase: { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::OnePhase; \
onePhaseCode; \
break; \
} \
}
// The static_assert does not compile with gcc 12 and earlier when placed in the multiplexer below.
#if defined(__GNUC__) && (__GNUC__ < 13)
#define STATIC_ASSERT_ECL_MULTIPLEXER_UNLESS_GCC_LT_13 throw std::logic_error("Unhandled EclMultiplexerApproach")
#else
#define STATIC_ASSERT_ECL_MULTIPLEXER_UNLESS_GCC_LT_13 static_assert(false, "Unhandled EclMultiplexerApproach")
#endif
#define OPM_ECL_MULTIPLEXER_MATERIAL_CALL_COMPILETIME(codeToCall, onePhaseCode) \
if constexpr (Head::approach == EclMultiplexerApproach::Stone1) { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Stone1; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = Stone1Material; \
codeToCall; \
} else if constexpr (Head::approach == EclMultiplexerApproach::Stone2) { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Stone2; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = Stone2Material; \
codeToCall; \
} else if constexpr (Head::approach == EclMultiplexerApproach::Default) { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Default; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = DefaultMaterial; \
codeToCall; \
} else if constexpr (Head::approach == EclMultiplexerApproach::TwoPhase) { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::TwoPhase; \
auto& realParams = params.template getRealParams<approach>(); \
using ActualLaw = TwoPhaseMaterial; \
codeToCall; \
} else if constexpr (Head::approach == EclMultiplexerApproach::OnePhase) { \
[[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::OnePhase; \
onePhaseCode; \
} else { \
STATIC_ASSERT_ECL_MULTIPLEXER_UNLESS_GCC_LT_13; \
}
// Pass this for the onePhaseCode argument if nothing is to be done.
inline void doNothing() { };
template <class TraitsT,
class GasOilMaterialLawT,
class OilWaterMaterialLawT,
class GasWaterMaterialLawT,
class ParamsT = EclMultiplexerMaterialParams<TraitsT,
GasOilMaterialLawT,
OilWaterMaterialLawT,
GasWaterMaterialLawT> >
class EclMultiplexerMaterial : public TraitsT
{
public:
using GasOilMaterialLaw = GasOilMaterialLawT;
using OilWaterMaterialLaw = OilWaterMaterialLawT;
using GasWaterMaterialLaw = GasWaterMaterialLawT;
using Stone1Material = EclStone1Material<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw>;
using Stone2Material = EclStone2Material<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw>;
using DefaultMaterial = EclDefaultMaterial<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw>;
using TwoPhaseMaterial = EclTwoPhaseMaterial<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw, GasWaterMaterialLaw>;
// some safety checks
static_assert(TraitsT::numPhases == 3,
"The number of phases considered by this capillary pressure "
"law is always three!");
static_assert(GasOilMaterialLaw::numPhases == 2,
"The number of phases considered by the gas-oil capillary "
"pressure law must be two!");
static_assert(OilWaterMaterialLaw::numPhases == 2,
"The number of phases considered by the oil-water capillary "
"pressure law must be two!");
static_assert(GasWaterMaterialLaw::numPhases == 2,
"The number of phases considered by the gas-water capillary "
"pressure law must be two!");
static_assert(std::is_same<typename GasOilMaterialLaw::Scalar,
typename OilWaterMaterialLaw::Scalar>::value,
"The two two-phase capillary pressure laws must use the same "
"type of floating point values.");
using Traits = TraitsT;
using Params = ParamsT;
using Scalar = typename Traits::Scalar;
static constexpr int numPhases = 3;
static constexpr int waterPhaseIdx = Traits::wettingPhaseIdx;
static constexpr int oilPhaseIdx = Traits::nonWettingPhaseIdx;
static constexpr int gasPhaseIdx = Traits::gasPhaseIdx;
static constexpr bool implementsTwoPhaseApi = false;
static constexpr bool implementsTwoPhaseSatApi = false;
static constexpr bool isSaturationDependent = true;
static constexpr bool isPressureDependent = false;
static constexpr bool isTemperatureDependent = false;
static constexpr bool isCompositionDependent = false;
template <class ContainerT, class FluidState, class ...Args>
static void capillaryPressures(ContainerT& values,
const Params& params,
const FluidState& fluidState)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
if constexpr (FrontIsEclMultiplexerDispatchV<Args...>) {
capillaryPressuresT<ContainerT, FluidState, Args...>(values, params, fluidState);
return;
}
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(ActualLaw::capillaryPressures(values, realParams, fluidState),
values[0] = 0.0);
}
template <class ContainerT, class FluidState, class Head, class ...Args>
static void capillaryPressuresT(ContainerT& values,
const Params& params,
const FluidState& fluidState)
{
#define OPM_LOCAL_TEMPLATE_ARGS ContainerT, FluidState, Args...
OPM_ECL_MULTIPLEXER_MATERIAL_CALL_COMPILETIME(
ActualLaw::template capillaryPressures<OPM_LOCAL_TEMPLATE_ARGS>(values, realParams, fluidState),
values[0] = 0.0
);
#undef OPM_LOCAL_TEMPLATE_ARGS
}
/*
* Hysteresis parameters for oil-water
* @see EclHysteresisTwoPhaseLawParams::soMax(...)
* @see EclHysteresisTwoPhaseLawParams::swMax(...)
* @see EclHysteresisTwoPhaseLawParams::swMin(...)
* \param params Parameters
*/
static void oilWaterHysteresisParams(Scalar& soMax,
Scalar& swMax,
Scalar& swMin,
const Params& params)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(ActualLaw::oilWaterHysteresisParams(soMax, swMax, swMin, realParams),
doNothing());
}
/*
* Hysteresis parameters for oil-water
* @see EclHysteresisTwoPhaseLawParams::soMax(...)
* @see EclHysteresisTwoPhaseLawParams::swMax(...)
* @see EclHysteresisTwoPhaseLawParams::swMin(...)
* \param params Parameters
*/
static void setOilWaterHysteresisParams(const Scalar& soMax,
const Scalar& swMax,
const Scalar& swMin,
Params& params)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(ActualLaw::setOilWaterHysteresisParams(soMax, swMax, swMin, realParams),
doNothing());
}
/*
* Hysteresis parameters for gas-oil
* @see EclHysteresisTwoPhaseLawParams::sgmax(...)
* @see EclHysteresisTwoPhaseLawParams::shmax(...)
* @see EclHysteresisTwoPhaseLawParams::somin(...)
* \param params Parameters
*/
static void gasOilHysteresisParams(Scalar& sgmax,
Scalar& shmax,
Scalar& somin,
const Params& params)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(ActualLaw::gasOilHysteresisParams(sgmax, shmax, somin, realParams),
doNothing());
}
static Scalar trappedGasSaturation(const Params& params, bool maximumTrapping)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(return ActualLaw::trappedGasSaturation(realParams, maximumTrapping),
return 0.0);
return 0.0;
}
static Scalar strandedGasSaturation(const Params& params, Scalar Sg, Scalar Kg)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(return ActualLaw::strandedGasSaturation(realParams, Sg, Kg),
return 0.0);
return 0.0;
}
static Scalar trappedOilSaturation(const Params& params, bool maximumTrapping)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(return ActualLaw::trappedOilSaturation(realParams, maximumTrapping),
return 0.0);
return 0.0;
}
static Scalar trappedWaterSaturation(const Params& params)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(return ActualLaw::trappedWaterSaturation(realParams),
return 0.0);
return 0.0;
}
/*
* Hysteresis parameters for gas-oil
* @see EclHysteresisTwoPhaseLawParams::sgmax(...)
* @see EclHysteresisTwoPhaseLawParams::shmax(...)
* @see EclHysteresisTwoPhaseLawParams::somin(...)
* \param params Parameters
*/
static void setGasOilHysteresisParams(const Scalar& sgmax,
const Scalar& shmax,
const Scalar& somin,
Params& params)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(ActualLaw::setGasOilHysteresisParams(sgmax, shmax, somin, realParams),
doNothing());
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation pcgn(const Params& /* params */,
const FluidState& /* fs */)
{
throw std::logic_error("Not implemented: pcgn()");
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation pcnw(const Params& /* params */,
const FluidState& /* fs */)
{
throw std::logic_error("Not implemented: pcnw()");
}
template <class ContainerT, class FluidState>
static void saturations(ContainerT& /* values */,
const Params& /* params */,
const FluidState& /* fs */)
{
throw std::logic_error("Not implemented: saturations()");
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation Sg(const Params& /* params */,
const FluidState& /* fluidState */)
{
throw std::logic_error("Not implemented: Sg()");
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation Sn(const Params& /* params */,
const FluidState& /* fluidState */)
{
throw std::logic_error("Not implemented: Sn()");
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation Sw(const Params& /* params */,
const FluidState& /* fluidState */)
{
throw std::logic_error("Not implemented: Sw()");
}
template <class ContainerT, class FluidState, class ...Args>
static void relativePermeabilities(ContainerT& values,
const Params& params,
const FluidState& fluidState)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
if constexpr (FrontIsEclMultiplexerDispatchV<Args...>) {
relativePermeabilitiesT<ContainerT, FluidState, Args...>(values, params, fluidState);
return;
}
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(ActualLaw::relativePermeabilities(values, realParams, fluidState),
values[0] = 1.0);
}
template <class ContainerT, class FluidState, class Head, class ...Args>
static void relativePermeabilitiesT(ContainerT& values,
const Params& params,
const FluidState& fluidState)
{
#define OPM_LOCAL_TEMPLATE_ARGS ContainerT, FluidState, Args...
OPM_ECL_MULTIPLEXER_MATERIAL_CALL_COMPILETIME(
ActualLaw::template relativePermeabilities<OPM_LOCAL_TEMPLATE_ARGS>(values, realParams, fluidState),
values[0] = 1.0
);
#undef OPM_LOCAL_TEMPLATE_ARGS
}
template <class Evaluation, class FluidState>
static Evaluation relpermOilInOilGasSystem(const Params& params,
const FluidState& fluidState)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
switch (params.approach()) {
case EclMultiplexerApproach::Stone1:
return Stone1Material::template relpermOilInOilGasSystem<Evaluation>
(params.template getRealParams<EclMultiplexerApproach::Stone1>(),
fluidState);
case EclMultiplexerApproach::Stone2:
return Stone2Material::template relpermOilInOilGasSystem<Evaluation>
(params.template getRealParams<EclMultiplexerApproach::Stone2>(),
fluidState);
case EclMultiplexerApproach::Default:
return DefaultMaterial::template relpermOilInOilGasSystem<Evaluation>
(params.template getRealParams<EclMultiplexerApproach::Default>(),
fluidState);
default:
throw std::logic_error {
"relpermOilInOilGasSystem() is specific to three phases"
};
}
}
template <class Evaluation, class FluidState>
static Evaluation relpermOilInOilWaterSystem(const Params& params,
const FluidState& fluidState)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
switch (params.approach()) {
case EclMultiplexerApproach::Stone1:
return Stone1Material::template relpermOilInOilWaterSystem<Evaluation>
(params.template getRealParams<EclMultiplexerApproach::Stone1>(),
fluidState);
case EclMultiplexerApproach::Stone2:
return Stone2Material::template relpermOilInOilWaterSystem<Evaluation>
(params.template getRealParams<EclMultiplexerApproach::Stone2>(),
fluidState);
case EclMultiplexerApproach::Default:
return DefaultMaterial::template relpermOilInOilWaterSystem<Evaluation>
(params.template getRealParams<EclMultiplexerApproach::Default>(),
fluidState);
default:
throw std::logic_error {
"relpermOilInOilWaterSystem() is specific to three phases"
};
}
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation krg(const Params& /* params */,
const FluidState& /* fluidState */)
{
throw std::logic_error("Not implemented: krg()");
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation krw(const Params& /* params */,
const FluidState& /* fluidState */)
{
throw std::logic_error("Not implemented: krw()");
}
template <class FluidState, class Evaluation = typename FluidState::Scalar>
static Evaluation krn(const Params& /* params */,
const FluidState& /* fluidState */)
{
throw std::logic_error("Not implemented: krn()");
}
template <class FluidState>
static bool updateHysteresis(Params& params, const FluidState& fluidState)
{
OPM_TIMEFUNCTION_LOCAL(Subsystem::SatProps);
OPM_ECL_MULTIPLEXER_MATERIAL_CALL(return ActualLaw::updateHysteresis(realParams, fluidState),
return false);
return false;
}
};
} // namespace Opm
#endif
EclDefaultMaterial.hpp
Implements the default three phase capillary pressure law used by the ECLipse simulator.
EclMultiplexerMaterialParams.hpp
Multiplexer implementation for the parameters required by the multiplexed three-phase material law.
EclStone1Material.hpp
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
EclStone2Material.hpp
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
EclTwoPhaseMaterial.hpp
Implements a multiplexer class that provides ECL saturation functions for twophase simulations.
Opm::EclDefaultMaterial
Implements the default three phase capillary pressure law used by the ECLipse simulator.
Definition EclDefaultMaterial.hpp:62
Opm::EclMultiplexerMaterialParams
Multiplexer implementation for the parameters required by the multiplexed three-phase material law.
Definition EclMultiplexerMaterialParams.hpp:75
Opm::EclMultiplexerMaterial
Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLi...
Definition EclMultiplexerMaterial.hpp:133
Opm::EclMultiplexerMaterial::relpermOilInOilWaterSystem
static Evaluation relpermOilInOilWaterSystem(const Params &params, const FluidState &fluidState)
The relative permeability of oil in oil/water system.
Definition EclMultiplexerMaterial.hpp:489
Opm::EclMultiplexerMaterial::krw
static Evaluation krw(const Params &, const FluidState &)
The relative permeability of the wetting phase.
Definition EclMultiplexerMaterial.hpp:530
Opm::EclMultiplexerMaterial::Sg
static Evaluation Sg(const Params &, const FluidState &)
The saturation of the gas phase.
Definition EclMultiplexerMaterial.hpp:383
Opm::EclMultiplexerMaterial::relpermOilInOilGasSystem
static Evaluation relpermOilInOilGasSystem(const Params &params, const FluidState &fluidState)
The relative permeability of oil in oil/gas system.
Definition EclMultiplexerMaterial.hpp:458
Opm::EclMultiplexerMaterial::pcgn
static Evaluation pcgn(const Params &, const FluidState &)
Capillary pressure between the gas and the non-wetting liquid (i.e., oil) phase.
Definition EclMultiplexerMaterial.hpp:346
Opm::EclMultiplexerMaterial::relativePermeabilities
static void relativePermeabilities(ContainerT &values, const Params &params, const FluidState &fluidState)
The relative permeability of all phases.
Definition EclMultiplexerMaterial.hpp:425
Opm::EclMultiplexerMaterial::pcnw
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:362
Opm::EclMultiplexerMaterial< Traits, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasOilLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::OilWaterLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasWaterLaw >::isPressureDependent
static constexpr bool isPressureDependent
Definition EclMultiplexerMaterial.hpp:185
Opm::EclMultiplexerMaterial< Traits, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasOilLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::OilWaterLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasWaterLaw >::implementsTwoPhaseSatApi
static constexpr bool implementsTwoPhaseSatApi
Definition EclMultiplexerMaterial.hpp:177
Opm::EclMultiplexerMaterial< Traits, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasOilLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::OilWaterLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasWaterLaw >::isSaturationDependent
static constexpr bool isSaturationDependent
Definition EclMultiplexerMaterial.hpp:181
Opm::EclMultiplexerMaterial< Traits, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasOilLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::OilWaterLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasWaterLaw >::isTemperatureDependent
static constexpr bool isTemperatureDependent
Definition EclMultiplexerMaterial.hpp:189
Opm::EclMultiplexerMaterial< Traits, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasOilLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::OilWaterLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasWaterLaw >::implementsTwoPhaseApi
static constexpr bool implementsTwoPhaseApi
Definition EclMultiplexerMaterial.hpp:173
Opm::EclMultiplexerMaterial::Sn
static Evaluation Sn(const Params &, const FluidState &)
The saturation of the non-wetting (i.e., oil) phase.
Definition EclMultiplexerMaterial.hpp:393
Opm::EclMultiplexerMaterial::krg
static Evaluation krg(const Params &, const FluidState &)
The relative permeability of the gas phase.
Definition EclMultiplexerMaterial.hpp:520
Opm::EclMultiplexerMaterial::capillaryPressures
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:210
Opm::EclMultiplexerMaterial< Traits, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasOilLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::OilWaterLaw, typename EclMaterialLaw::TwoPhaseTypes< Traits >::GasWaterLaw >::isCompositionDependent
static constexpr bool isCompositionDependent
Definition EclMultiplexerMaterial.hpp:193
Opm::EclMultiplexerMaterial::saturations
static void saturations(ContainerT &, const Params &, const FluidState &)
The inverse of the capillary pressure.
Definition EclMultiplexerMaterial.hpp:372
Opm::EclMultiplexerMaterial::krn
static Evaluation krn(const Params &, const FluidState &)
The relative permeability of the non-wetting (i.e., oil) phase.
Definition EclMultiplexerMaterial.hpp:540
Opm::EclMultiplexerMaterial::Sw
static Evaluation Sw(const Params &, const FluidState &)
The saturation of the wetting (i.e., water) phase.
Definition EclMultiplexerMaterial.hpp:403
Opm::EclMultiplexerMaterial::updateHysteresis
static bool updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition EclMultiplexerMaterial.hpp:555
Opm::EclStone1Material
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
Definition EclStone1Material.hpp:61
Opm::EclStone2Material
Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse ...
Definition EclStone2Material.hpp:61
Opm::EclTwoPhaseMaterial
Implements a multiplexer class that provides ECL saturation functions for twophase simulations.
Definition EclTwoPhaseMaterial.hpp:57
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30