def test_wateroil_krendmax(swl, swcr, sorw, kroend, kromax, krwend, krwmax, h, fast):
"""Test endpoints for wateroil using hypothesis testing"""
try:
wateroil = WaterOil(swl=swl, swcr=swcr, sorw=sorw, h=h, fast=fast)
except AssertionError:
return
kroend = min(kroend, kromax)
krwend = min(krwend, krwmax)
wateroil.add_corey_oil(kroend=kroend, kromax=kromax)
wateroil.add_corey_water(krwend=krwend, krwmax=krwmax)
check_table(wateroil.table)
assert wateroil.selfcheck()
assert 0 < wateroil.crosspoint() < 1
check_endpoints(wateroil, krwend, krwmax, kroend, kromax)
####################################
# Do it over again, but with LET:
wateroil.add_LET_oil(t=1.1, kroend=kroend, kromax=kromax)
wateroil.add_LET_water(t=1.1, krwend=krwend, krwmax=krwmax)
assert wateroil.selfcheck()
check_table(wateroil.table)
# Check endpoints for oil curve:
check_endpoints(wateroil, krwend, krwmax, kroend, kromax)
check_linear_sections(wateroil)
assert 0 < wateroil.crosspoint() < 1
def test_interpolation_art():
"""This code was used to create the Pyscal logo (50 repeats and 30 interpolants)"""
repeats = 15
interpolants = 30
curvetype = "corey"
cmap = pyplot.get_cmap("viridis")
_, mpl_ax = pyplot.subplots()
for _ in range(repeats):
swl = random.uniform(0, 0.1)
swcr = swl + random.uniform(0, 0.1)
sorw = random.uniform(0, 0.2)
wo_low = WaterOil(swl=swl, swcr=swcr, sorw=sorw)
wo_high = WaterOil(swl=swl + 0.1, swcr=swcr + 0.1, sorw=sorw + 0.1)
if curvetype == "corey":
wo_low.add_corey_water(nw=random.uniform(1, 3),
krwend=random.uniform(0.5, 1))
wo_high.add_corey_water(nw=random.uniform(1, 3),
krwend=random.uniform(0.5, 1))
wo_low.add_corey_oil(now=random.uniform(1, 3),
kroend=random.uniform(0.5, 1))
wo_high.add_corey_oil(now=random.uniform(1, 3),
kroend=random.uniform(0.5, 1))
elif curvetype == "let":
wo_low.add_LET_water(
l=random.uniform(1, 3),
e=random.uniform(1, 3),
t=random.uniform(1, 3),
krwend=random.uniform(0.5, 1),
)
wo_high.add_LET_water(
l=random.uniform(1, 3),
e=random.uniform(1, 3),
t=random.uniform(1, 3),
krwend=random.uniform(0.5, 1),
)
wo_low.add_LET_oil(
l=random.uniform(1, 3),
e=random.uniform(1, 3),
t=random.uniform(1, 3),
kroend=random.uniform(0.5, 1),
)
wo_high.add_LET_oil(
l=random.uniform(1, 3),
e=random.uniform(1, 3),
t=random.uniform(1, 3),
kroend=random.uniform(0.5, 1),
)
else:
print("ERROR, wrong curvetype")
color = cmap(random.random())
for tparam in np.arange(0, 1, 1.0 / interpolants):
wo_ip = utils.interpolation.interpolate_wo(wo_low, wo_high, tparam)
wo_ip.plotkrwkrow(mpl_ax, color=color, alpha=0.3)
pyplot.title("Pyscal art")
pyplot.show()
def test_wateroil_let1(l, e, t, krwend, krwmax):
wo = WaterOil()
try:
wo.add_LET_oil(l, e, t, krwend, krwmax)
wo.add_LET_water(l, e, t, krwend, krwmax)
except AssertionError:
# This happens for negative values f.ex.
return
assert "krow" in wo.table
assert "krw" in wo.table
assert isinstance(wo.krwcomment, str)
check_table(wo.table)
swofstr = wo.SWOF()
assert len(swofstr) > 100
def testplot():
"""Generate and plot relperm curves
Use this as a template function.
"""
swof = WaterOil(tag="Testcurve", h=0.01, swirr=0.2, swl=0.2, sorw=0.1)
swof.add_corey_water(nw=5, krwend=0.7, krwmax=0.9)
swof.add_corey_oil(now=2, kroend=0.95)
swof.add_LET_water(l=2, e=1, t=1.4, krwend=0.7, krwmax=0.9)
swof.add_LET_oil(l=2, e=1, t=1.4, kroend=0.9)
# Print the first 7 lines of SWOF:
print("\n".join(swof.SWOF().split("\n")[0:8]))
_, mpl_ax = plt.subplots()
swof.plotkrwkrow(mpl_ax)
plt.show()
def test_wateroil_let1(l, e, t, krwend, krwmax):
"""Test random LET parameters"""
wateroil = WaterOil()
try:
wateroil.add_LET_oil(l, e, t, krwend)
wateroil.add_LET_water(l, e, t, krwend, krwmax)
except AssertionError:
# This happens for negative values f.ex.
return
assert "KROW" in wateroil.table
assert "KRW" in wateroil.table
assert isinstance(wateroil.krwcomment, str)
check_table(wateroil.table)
check_linear_sections(wateroil)
swofstr = wateroil.SWOF()
assert len(swofstr) > 100
def test_wateroil_krendmax(swl, swcr, sorw, kroend, kromax, krwend, krwmax, h):
try:
wo = WaterOil(swl=swl, swcr=swcr, sorw=sorw, h=h)
except AssertionError:
return
kroend = min(kroend, kromax)
krwend = min(krwend, krwmax)
wo.add_corey_oil(kroend=kroend, kromax=kromax)
wo.add_corey_water(krwend=krwend, krwmax=krwmax)
check_table(wo.table)
assert wo.selfcheck()
check_endpoints(wo, krwend, krwmax, kroend, kromax)
####################################
# Do it over again, but with LET:
wo.add_LET_oil(kroend=kroend, kromax=kromax)
wo.add_LET_water(krwend=krwend, krwmax=krwmax)
assert wo.selfcheck()
check_table(wo.table)
# Check endpoints for oil curve:
check_endpoints(wo, krwend, krwmax, kroend, kromax)
def test_letspan():
"""Demonstration of how random LET (random individually and
uncorrelated in L, eand T) curves span out the relperm-space
between low and high LET curves
If the low and high LET curves do not cross, the random
curves are all between the low and high curves.
"""
matplotlib.style.use("ggplot")
let_w = {
"l": [2, 4],
"e": [1, 2],
"t": [2,
1], # first value should be larger than first to avoid crossing
"krwend": [0.9, 0.5],
"sorw": [0.05, 0.1],
}
# Parameter test set from SCAL group, first is pessimistic, second
# is optimistic
let_w = {
"l": [2.323, 4.436],
"e": [2, 8],
"t": [1.329, 0.766], # first value should be larger
# than first to avoid crossing
"krwend": [0.9, 0.6],
"sorw": [0.02, 0.137],
}
# LET oil:
let_o = {
"l": [4.944, 2.537],
"e": [5, 2],
"t": [0.68, 1.549], # first value should be larger
# than first to avoid crossing
"kroend": [1, 1],
"sorw": [0.02, 0.137],
}
# We need sorted versions for the random function
slimw = {x: sorted(let_w[x]) for x in let_w}
slimo = {x: sorted(let_o[x]) for x in let_o}
_, mpl_ax = pyplot.subplots()
for _ in range(100):
swof = WaterOil(h=0.01,
swl=0.16,
sorw=random.uniform(slimw["sorw"][0],
slimw["sorw"][1]))
swof.add_LET_water(
l=random.uniform(slimw["l"][0], slimw["l"][1]),
e=random.uniform(slimw["e"][0], slimw["e"][1]),
t=random.uniform(slimw["t"][0], slimw["t"][1]),
krwend=random.uniform(slimw["krwend"][0], slimw["krwend"][1]),
)
swof.add_LET_oil(
l=random.uniform(slimo["l"][0], slimo["l"][1]),
e=random.uniform(slimo["e"][0], slimo["e"][1]),
t=random.uniform(slimo["t"][0], slimo["t"][1]),
)
swof.plotkrwkrow(mpl_ax=mpl_ax, alpha=0.1)
# Boundary lines
swof = WaterOil(h=0.01, sorw=let_w["sorw"][0], swl=0.16)
swof.add_LET_water(l=let_w["l"][0],
e=let_w["e"][0],
t=let_w["t"][0],
krwend=let_w["krwend"][0])
swof.add_LET_oil(l=let_o["l"][0], e=let_o["e"][0], t=let_o["t"][0])
swof.plotkrwkrow(mpl_ax=mpl_ax, color="red", label="Low")
swof = WaterOil(h=0.01, sorw=let_w["sorw"][1], swl=0.16)
swof.add_LET_water(l=let_w["l"][1],
e=let_w["e"][1],
t=let_w["t"][1],
krwend=let_w["krwend"][1])
swof.add_LET_oil(l=let_o["l"][1], e=let_o["e"][1], t=let_o["t"][1])
swof.plotkrwkrow(mpl_ax=mpl_ax, color="red", label="High")
pyplot.subplots_adjust(top=0.8)
pyplot.title(
"Blue LET curves go outside red boundaries, \n"
"therefore SCAL-interpolation "
"must be done\n on curves, not in LET-space.",
fontsize=12,
)
print("[Close windows to continue tests]")
pyplot.show()
def letspan():
"""Demonstration of how random LET (random individually and
uncorrelated in L, eand T) curves span out the relperm-space
between low and high LET curves
If the low and high LET curves do not cross, the random
curves are all between the low and high curves.
"""
import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use("ggplot")
let_w = {
"l": [2, 4],
"e": [1, 2],
"t": [2,
1], # first value should be larger than first to avoid crossing
"krwend": [0.9, 0.5],
"sorw": [0.05, 0.1],
}
# Parameter test set from SCAL group, first is pessimistic, second
# is optimistic
let_w = {
"l": [2.323, 4.436],
"e": [2, 8],
"t": [1.329, 0.766], # first value should be larger
# than first to avoid crossing
"krwend": [0.9, 0.6],
"sorw": [0.02, 0.137],
}
# LET oil:
let_o = {
"l": [4.944, 2.537],
"e": [5, 2],
"t": [0.68, 1.549], # first value should be larger
# than first to avoid crossing
"kroend": [1, 1],
"sorw": [0.02, 0.137],
}
# We need sorted versions for the random function
slimw = {x: sorted(let_w[x]) for x in let_w}
slimo = {x: sorted(let_o[x]) for x in let_o}
_, mpl_ax = plt.subplots()
for _ in range(100):
swof = WaterOil(h=0.01,
swl=0.16,
sorw=random.uniform(slimw["sorw"][0],
slimw["sorw"][1]))
swof.add_LET_water(
l=random.uniform(slimw["l"][0], slimw["l"][1]),
e=random.uniform(slimw["e"][0], slimw["e"][1]),
t=random.uniform(slimw["t"][0], slimw["t"][1]),
krwend=random.uniform(slimw["krwend"][0], slimw["krwend"][1]),
)
swof.add_LET_oil(
l=random.uniform(slimo["l"][0], slimo["l"][1]),
e=random.uniform(slimo["e"][0], slimo["e"][1]),
t=random.uniform(slimo["t"][0], slimo["t"][1]),
)
swof.plotkrwkrow(mpl_ax=mpl_ax, alpha=0.1)
# Boundary lines
swof = WaterOil(h=0.01, sorw=let_w["sorw"][0], swl=0.16)
swof.add_LET_water(l=let_w["l"][0],
e=let_w["e"][0],
t=let_w["t"][0],
krwend=let_w["krwend"][0])
swof.add_LET_oil(l=let_o["l"][0], e=let_o["e"][0], t=let_o["t"][0])
swof.plotkrwkrow(mpl_ax=mpl_ax, color="red", label="Low")
swof = WaterOil(h=0.01, sorw=let_w["sorw"][1], swl=0.16)
swof.add_LET_water(l=let_w["l"][1],
e=let_w["e"][1],
t=let_w["t"][1],
krwend=let_w["krwend"][1])
swof.add_LET_oil(l=let_o["l"][1], e=let_o["e"][1], t=let_o["t"][1])
swof.plotkrwkrow(mpl_ax=mpl_ax, color="red", label="High")
# mpl_ax.set_yscale('log')
plt.show()
def create_water_oil(params=None):
"""Create a WaterOil object from a dictionary of parameters.
Parameterization (Corey/LET) is inferred from presence
of certain parameters in the dictionary.
Don't rely on behaviour of you supply both Corey and LET at
the same time.
Parameter names in the dictionary are case insensitive. You
can use Swirr, swirr, sWirR, swiRR etc.
NB: the add_LET_* methods have the names 'l', 'e' and 't'
in their signatures, which is not precise enough in this
context, so we require e.g. 'Lw' and 'Low' (which both will be
translated to 'l')
Recognized parameters:
swirr, swl, swcr, sorw, h, tag, nw, now, krwmax, krwend,
lw, ew, tw, low, eow, tow, lo, eo, to, kromax, krowend,
a, a_petro, b, b_petro, poro_ref, perm_ref, drho,
a, b, poro, perm, sigma_costau
Args:
params (dict): Dictionary with parameters describing
the WaterOil object.
"""
if not params:
params = dict()
if not isinstance(params, dict):
raise TypeError(
"Parameter to create_water_oil must be a dictionary")
check_deprecated(params)
# For case insensitiveness, all keys are converted to lower case:
params = {key.lower(): value for (key, value) in params.items()}
# Allowing sending in NaN values, delete those keys.
params = filter_nan_from_dict(params)
usedparams = set()
# No requirements to the base objects, defaults are ok.
wateroil = WaterOil(**slicedict(params, WO_INIT))
usedparams = usedparams.union(set(slicedict(params, WO_INIT).keys()))
logger.info("Initialized WaterOil object from parameters %s",
str(list(usedparams)))
# Water curve
params_corey_water = slicedict(params,
WO_COREY_WATER + WO_WATER_ENDPOINTS)
params_let_water = slicedict(params, WO_LET_WATER + WO_WATER_ENDPOINTS)
if set(WO_COREY_WATER).issubset(set(params_corey_water)):
wateroil.add_corey_water(**params_corey_water)
usedparams = usedparams.union(set(params_corey_water.keys()))
logger.info(
"Added Corey water to WaterOil object from parameters %s",
str(params_corey_water.keys()),
)
elif set(WO_LET_WATER).issubset(set(params_let_water)):
params_let_water["l"] = params_let_water.pop("lw")
params_let_water["e"] = params_let_water.pop("ew")
params_let_water["t"] = params_let_water.pop("tw")
wateroil.add_LET_water(**params_let_water)
usedparams = usedparams.union(set(params_let_water.keys()))
logger.info(
"Added LET water to WaterOil object from parameters %s",
str(params_let_water.keys()),
)
else:
logger.warning(
"Missing or ambiguous parameters for water curve in WaterOil object"
)
# Oil curve:
params_corey_oil = slicedict(params, WO_COREY_OIL + WO_OIL_ENDPOINTS)
params_let_oil = slicedict(
params, WO_LET_OIL + WO_LET_OIL_ALT + WO_OIL_ENDPOINTS)
if set(WO_COREY_OIL).issubset(set(params_corey_oil)):
if "krowend" in params_corey_oil:
params_corey_oil["kroend"] = params_corey_oil.pop("krowend")
wateroil.add_corey_oil(**params_corey_oil)
logger.info(
"Added Corey water to WaterOil object from parameters %s",
str(params_corey_oil.keys()),
)
elif set(WO_LET_OIL).issubset(set(params_let_oil)):
params_let_oil["l"] = params_let_oil.pop("low")
params_let_oil["e"] = params_let_oil.pop("eow")
params_let_oil["t"] = params_let_oil.pop("tow")
if "krowend" in params_let_oil:
params_let_oil["kroend"] = params_let_oil.pop("krowend")
wateroil.add_LET_oil(**params_let_oil)
logger.info(
"Added LET water to WaterOil object from parameters %s",
str(params_let_oil.keys()),
)
elif set(WO_LET_OIL_ALT).issubset(set(params_let_oil)):
params_let_oil["l"] = params_let_oil.pop("lo")
params_let_oil["e"] = params_let_oil.pop("eo")
params_let_oil["t"] = params_let_oil.pop("to")
if "krowend" in params_let_oil:
params_let_oil["kroend"] = params_let_oil.pop("krowend")
wateroil.add_LET_oil(**params_let_oil)
logger.info(
"Added LET water to WaterOil object from parameters %s",
str(params_let_oil.keys()),
)
else:
logger.warning(
"Missing or ambiguous parameters for oil curve in WaterOil object"
)
# Capillary pressure:
params_simple_j = slicedict(params, WO_SIMPLE_J + ["g"])
params_norm_j = slicedict(params, WO_NORM_J)
params_simple_j_petro = slicedict(params, WO_SIMPLE_J_PETRO + ["g"])
if set(WO_SIMPLE_J).issubset(set(params_simple_j)):
wateroil.add_simple_J(**params_simple_j)
elif set(WO_SIMPLE_J_PETRO).issubset(set(params_simple_j_petro)):
params_simple_j_petro["a"] = params_simple_j_petro.pop("a_petro")
params_simple_j_petro["b"] = params_simple_j_petro.pop("b_petro")
wateroil.add_simple_J_petro(**params_simple_j_petro)
elif set(WO_NORM_J).issubset(set(params_norm_j)):
wateroil.add_normalized_J(**params_norm_j)
else:
logger.warning(
("Missing or ambiguous parameters for capillary pressure in "
"WaterOil object. Using zero."))
if not wateroil.selfcheck():
raise ValueError((
"Incomplete WaterOil object, some parameters missing to factory"
))
return wateroil
def create_water_oil(params=None):
"""Create a WaterOil object from a dictionary of parameters.
Parameterization (Corey/LET) is inferred from presence
of certain parameters in the dictionary.
Don't rely on behaviour of you supply both Corey and LET at
the same time.
Parameter names in the dictionary are case insensitive. You
can use Swirr, swirr, sWirR, swiRR etc.
NB: the add_LET_* methods have the names 'l', 'e' and 't'
in their signatures, which is not precise enough in this
context, so we require e.g. 'Lw' and 'Low' (which both will be
translated to 'l')
"""
if not params:
params = dict()
if not isinstance(params, dict):
raise TypeError(
"Parameter to create_water_oil must be a dictionary")
# For case insensitiveness, all keys are converted to lower case:
params = {key.lower(): value for (key, value) in params.items()}
usedparams = set()
# No requirements to the base objects, defaults are ok.
wateroil = WaterOil(**slicedict(params, WO_INIT))
usedparams = usedparams.union(set(slicedict(params, WO_INIT).keys()))
logging.info("Initialized WaterOil object from parameters %s",
str(list(usedparams)))
# Water curve
params_corey_water = slicedict(params,
WO_COREY_WATER + WO_WATER_ENDPOINTS)
params_let_water = slicedict(params, WO_LET_WATER + WO_WATER_ENDPOINTS)
if set(WO_COREY_WATER).issubset(set(params_corey_water)):
wateroil.add_corey_water(**params_corey_water)
usedparams = usedparams.union(set(params_corey_water.keys()))
logging.info(
"Added Corey water to WaterOil object from parameters %s",
str(params_corey_water.keys()),
)
elif set(WO_LET_WATER).issubset(set(params_let_water)):
params_let_water["l"] = params_let_water.pop("lw")
params_let_water["e"] = params_let_water.pop("ew")
params_let_water["t"] = params_let_water.pop("tw")
wateroil.add_LET_water(**params_let_water)
usedparams = usedparams.union(set(params_let_water.keys()))
logging.info(
"Added LET water to WaterOil object from parameters %s",
str(params_let_water.keys()),
)
else:
logging.warning(
"Missing or ambiguous parameters for water curve in WaterOil object"
)
# Oil curve:
params_corey_oil = slicedict(params, WO_COREY_OIL + WO_OIL_ENDPOINTS)
params_let_oil = slicedict(
params, WO_LET_OIL + WO_LET_OIL_ALT + WO_OIL_ENDPOINTS)
if set(WO_COREY_OIL).issubset(set(params_corey_oil)):
wateroil.add_corey_oil(**params_corey_oil)
logging.info(
"Added Corey water to WaterOil object from parameters %s",
str(params_corey_oil.keys()),
)
elif set(WO_LET_OIL).issubset(set(params_let_oil)):
params_let_oil["l"] = params_let_oil.pop("low")
params_let_oil["e"] = params_let_oil.pop("eow")
params_let_oil["t"] = params_let_oil.pop("tow")
wateroil.add_LET_oil(**params_let_oil)
logging.info(
"Added LET water to WaterOil object from parameters %s",
str(params_let_oil.keys()),
)
elif set(WO_LET_OIL_ALT).issubset(set(params_let_oil)):
params_let_oil["l"] = params_let_oil.pop("lo")
params_let_oil["e"] = params_let_oil.pop("eo")
params_let_oil["t"] = params_let_oil.pop("to")
wateroil.add_LET_oil(**params_let_oil)
logging.info(
"Added LET water to WaterOil object from parameters %s",
str(params_let_oil.keys()),
)
else:
logging.warning(
"Missing or ambiguous parameters for oil curve in WaterOil object"
)
# Capillary pressure:
params_simple_j = slicedict(params, WO_SIMPLE_J + ["g"])
params_norm_j = slicedict(params, WO_NORM_J)
if set(WO_SIMPLE_J).issubset(set(params_simple_j)):
wateroil.add_simple_J(**params_simple_j)
elif set(WO_NORM_J).issubset(set(params_norm_j)):
wateroil.add_normalized_J(**params_norm_j)
else:
logging.warning(
"Missing or ambiguous parameters for capillary pressure in WaterOil object. Using zero."
)
if not wateroil.selfcheck():
raise ValueError(("Incomplete WaterOil object, some parameters "
"missing to factory"))
return wateroil
