def test_pvt_reek():
"""Test that the Reek PVT input can be parsed individually"""
eclfiles = EclFiles(DATAFILE)
pvto_df = pvt.pvto_fromdeck(eclfiles.get_ecldeck())
assert "PVTNUM" in pvto_df
assert "PRESSURE" in pvto_df
assert "VOLUMEFACTOR" in pvto_df
assert "VISCOSITY" in pvto_df
assert max(pvto_df["PVTNUM"]) == 1
assert max(pvto_df["PRESSURE"]) == 700.1
# Check count of undersaturated lines pr. RS:
# (nb: double brackets in .loc to ensure dataframe is returned)
assert len(pvto_df.set_index("RS").loc[[0]]) == 2
assert len(pvto_df.set_index("RS").loc[[15.906]]) == 1
assert len(pvto_df.set_index("RS").loc[[105.5]]) == 15
assert len(pvto_df["RS"].unique()) == 20
assert pvto_df["VOLUMEFACTOR"].max() == 2.851
assert pvto_df["VISCOSITY"].max() == 1.0001
dframe_via_string = pvt.pvto_fromdeck(pvt.df2ecl_pvto(pvto_df))
pd.testing.assert_frame_equal(dframe_via_string, pvto_df)
density_df = pvt.density_fromdeck(eclfiles.get_ecldeck())
assert "PVTNUM" in density_df
assert "OILDENSITY" in density_df
assert "WATERDENSITY" in density_df
assert "GASDENSITY" in density_df
assert len(density_df) == 1
assert density_df["WATERDENSITY"].values[0] == 999.04
dframe_via_string = pvt.density_fromdeck(pvt.df2ecl_density(density_df))
pd.testing.assert_frame_equal(dframe_via_string, density_df)
rock_df = pvt.rock_fromdeck(eclfiles.get_ecldeck())
assert "PVTNUM" in rock_df
assert len(rock_df) == 1
assert "PRESSURE" in rock_df
assert "COMPRESSIBILITY" in rock_df
assert rock_df["PRESSURE"].values[0] == 327.3
pvtw_df = pvt.pvtw_fromdeck(eclfiles.get_ecldeck())
assert "PVTNUM" in pvtw_df
assert pvtw_df["PVTNUM"].values[0] == 1
assert len(pvtw_df) == 1
assert "PRESSURE" in pvtw_df
assert "VOLUMEFACTOR" in pvtw_df
assert "COMPRESSIBILITY" in pvtw_df
assert "VISCOSITY" in pvtw_df
assert "VISCOSIBILITY" in pvtw_df
assert pvtw_df["VISCOSITY"].values[0] == 0.25
pvdg_df = pvt.pvdg_fromdeck(eclfiles.get_ecldeck())
assert "PVTNUM" in pvdg_df
assert "PRESSURE" in pvdg_df
assert "VOLUMEFACTOR" in pvdg_df
assert "VISCOSITY" in pvdg_df
assert len(pvdg_df["PVTNUM"].unique()) == 1
assert pvdg_df["PVTNUM"].max() == 1
assert len(pvdg_df) == 15
def test_density():
"""Test that DENSITY can be parsed from files and from strings"""
eclfiles = EclFiles(DATAFILE)
density_df = pvt.density_fromdeck(eclfiles.get_ecldeck())
assert len(density_df) == 1
assert "PVTNUM" in density_df
assert "OILDENSITY" in density_df
assert "WATERDENSITY" in density_df
assert "GASDENSITY" in density_df
dframe_via_string = pvt.density_fromdeck(pvt.df2ecl_density(density_df))
pd.testing.assert_frame_equal(dframe_via_string, density_df)
two_pvtnum_deck = """DENSITY
860 999.04 1.1427 /
800 950 1.05
/
"""
density_df = pvt.density_fromdeck(EclFiles.str2deck(two_pvtnum_deck))
# (a warning will be printed that we cannot guess)
assert len(density_df) == 1
density_df = pvt.density_fromdeck(two_pvtnum_deck)
assert "PVTNUM" in density_df
assert density_df["PVTNUM"].max() == 2
assert density_df["PVTNUM"].min() == 1
assert "OILDENSITY" in density_df
dframe_via_string = pvt.density_fromdeck(pvt.df2ecl_density(density_df))
pd.testing.assert_frame_equal(dframe_via_string, density_df)
# Test emtpy data:
inc = pvt.df2ecl_density(pvt.df(""))
assert "No data" in inc
assert pvt.df(inc).empty
def test_ecldeck_to_satfunc_dframe():
"""Test that dataframes can be produced from a full Eclipse deck (the
example Reek case)"""
eclfiles = EclFiles(DATAFILE)
satdf = satfunc.df(eclfiles.get_ecldeck())
assert set(satdf["KEYWORD"]) == {"SWOF", "SGOF"}
assert set(satdf["SATNUM"]) == {1}
assert np.isclose(satdf["SW"].min(), 0.32)
assert np.isclose(satdf["SW"].max(), 1.0)
assert np.isclose(satdf["SG"].min(), 0.0)
assert np.isclose(satdf["SG"].max(), 1 - 0.32)
assert np.isclose(satdf["KRW"].min(), 0.0)
assert np.isclose(satdf["KRW"].max(), 1.0)
assert np.isclose(satdf["KROW"].min(), 0.0)
assert np.isclose(satdf["KROW"].max(), 1.0)
assert np.isclose(satdf["KROG"].min(), 0.0)
assert np.isclose(satdf["KROG"].max(), 1.0)
assert len(satdf) == 76
def test_gruptree2df():
"""Test that dataframes are produced"""
eclfiles = EclFiles(DATAFILE)
grupdf = gruptree.df(eclfiles.get_ecldeck())
assert not grupdf.empty
assert len(grupdf["DATE"].unique()) == 5
assert len(grupdf["CHILD"].unique()) == 10
assert len(grupdf["PARENT"].unique()) == 3
assert set(grupdf["KEYWORD"].unique()) == set(["GRUPTREE", "WELSPECS"])
grupdfnowells = gruptree.df(eclfiles.get_ecldeck(), welspecs=False)
assert len(grupdfnowells["KEYWORD"].unique()) == 1
assert grupdf["PARENT"].unique()[0] == "FIELD"
assert grupdf["KEYWORD"].unique()[0] == "GRUPTREE"
def df(eclfiles: EclFiles,
initvectors: Optional[List[str]] = None) -> pd.DataFrame:
"""Main function for Python API users
Supports only COMPDAT information for now. Will
add a zone-name if a zonefile is found alongside
Returns:
pd.Dataframe with one row pr cell to well connection
"""
compdat_df = deck2dfs(eclfiles.get_ecldeck())["COMPDAT"]
compdat_df = unrolldf(compdat_df)
if initvectors:
compdat_df = merge_initvectors(eclfiles,
compdat_df,
initvectors,
ijknames=["I", "J", "K1"])
zonemap = eclfiles.get_zonemap()
if zonemap:
logger.info("Merging zonemap into compdat")
compdat_df = merge_zones(compdat_df, zonemap)
return compdat_df
def test_wcon2df():
"""Test that dataframes are produced"""
eclfiles = EclFiles(DATAFILE)
wcondf = wcon.df(eclfiles.get_ecldeck())
assert not wcondf.empty
assert "DATE" in wcondf # for all data
assert "KEYWORD" in wcondf
for col in wcondf.columns:
assert col == col.upper()
def test_satfunc_roundtrip():
"""Test that we can produce a SATNUM dataframe from the Reek case, convert
it back to an include file, and then reinterpret it to the same"""
eclfiles = EclFiles(DATAFILE)
satdf = satfunc.df(eclfiles.get_ecldeck())
inc = satfunc.df2ecl(satdf)
df_from_inc = satfunc.df(inc)
pd.testing.assert_frame_equal(
satdf.sort_values(["SATNUM", "KEYWORD"]),
df_from_inc.sort_values(["SATNUM", "KEYWORD"]),
)
def test_faults2df():
"""Test that dataframes are produced"""
eclfiles = EclFiles(DATAFILE)
faultsdf = faults.df(eclfiles.get_ecldeck())
assert "NAME" in faultsdf
assert "I" in faultsdf
assert "J" in faultsdf
assert "K" in faultsdf
assert "FACE" in faultsdf
assert not faultsdf.empty
def test_df2ecl_order():
"""Test that we can control the keyword order in generated
strings by the list supplied in keywords argument"""
eclfiles = EclFiles(DATAFILE)
satdf = satfunc.df(eclfiles.get_ecldeck())
swof_sgof = satfunc.df2ecl(satdf, keywords=["SWOF", "SGOF"])
assert swof_sgof.find("SWOF") < swof_sgof.find("SGOF")
sgof_swof = satfunc.df2ecl(satdf, keywords=["SGOF", "SWOF"])
assert sgof_swof.find("SGOF") < sgof_swof.find("SWOF")
only_swof = satfunc.df2ecl(satdf, keywords=["SWOF"])
assert "SGOF" not in only_swof
only_sgof = satfunc.df2ecl(satdf, keywords="SGOF")
assert "SWOF" not in only_sgof
def test_eightcells_dataset():
"""Test Eightcells dataset"""
eclfiles = EclFiles(EIGHTCELLS)
gruptree_df = gruptree.df(eclfiles.get_ecldeck())
expected_dframe = pd.DataFrame(
[
["2000-01-01", "FIELD", "GRUPTREE", np.nan],
["2000-01-01", "OP1", "WELSPECS", "OPS"],
["2000-01-01", "OPS", "GRUPTREE", "FIELD"],
],
columns=["DATE", "CHILD", "KEYWORD", "PARENT"],
)
expected_dframe["DATE"] = pd.to_datetime(expected_dframe["DATE"])
pd.testing.assert_frame_equal(gruptree_df, expected_dframe, check_dtype=False)
def test_satfunc2df():
"""Test that dataframes are produced"""
eclfiles = EclFiles(DATAFILE)
satdf = satfunc.deck2df(eclfiles.get_ecldeck())
assert not satdf.empty
assert "KEYWORD" in satdf # for all data
assert "SATNUM" in satdf # for all data
assert "SWOF" in satdf["KEYWORD"].unique()
assert "SGOF" in satdf["KEYWORD"].unique()
assert "SW" in satdf
assert "KRW" in satdf
assert "KROW" in satdf
assert "SG" in satdf
assert "KROG" in satdf
assert satdf["SATNUM"].unique() == [1]
def test_nnc2df_faultnames():
"""Add faultnames from FAULTS keyword to connections"""
eclfiles = EclFiles(DATAFILE)
nncdf = nnc.df(eclfiles)
faultsdf = faults.df(eclfiles.get_ecldeck())
merged = pd.merge(
nncdf,
faultsdf,
how="left",
left_on=["I1", "J1", "K1"],
right_on=["I", "J", "K"],
)
merged = pd.merge(
merged,
faultsdf,
how="left",
left_on=["I2", "J2", "K2"],
right_on=["I", "J", "K"],
)
def test_satfunc2df():
"""Test that dataframes are produced"""
eclfiles = EclFiles(DATAFILE)
satdf = satfunc.deck2df(eclfiles.get_ecldeck())
assert not satdf.empty
assert "KEYWORD" in satdf # for all data
assert "SATNUM" in satdf # for all data
assert "SWOF" in satdf["KEYWORD"].unique()
assert "SGOF" in satdf["KEYWORD"].unique()
assert "SW" in satdf
assert "KRW" in satdf
assert "KROW" in satdf
assert "SG" in satdf
assert "KROG" in satdf
assert satdf["SATNUM"].unique() == [1]
inc = satfunc.df2ecl(satdf)
df_from_inc = satfunc.df(inc)
pd.testing.assert_frame_equal(
satdf.sort_values(["SATNUM", "KEYWORD"]),
df_from_inc.sort_values(["SATNUM", "KEYWORD"]),
)
def test_equil2df():
"""Test that dataframes are produced"""
eclfiles = EclFiles(DATAFILE)
equildf = equil.deck2df(eclfiles.get_ecldeck())
assert not equildf.empty
def test_nofaults():
"""Test on a dataset with no faults"""
eclfiles = EclFiles(EIGHTCELLS)
faultsdf = faults.df(eclfiles.get_ecldeck())
assert faultsdf.empty
