def test_decks():
"""Test some string decks"""
deckstr = """
OIL
WATER
GAS
EQUIL
2000 200 2200 /
"""
deck = EclFiles.str2deck(deckstr)
df = equil.deck2df(deck)
assert df["OWC"].values == 2200
assert len(df) == 1
assert "IGNORE1" not in df
deckstr = """
OIL
WATER
EQUIL
2000 200 2200 /
"""
deck = EclFiles.str2deck(deckstr)
df = equil.deck2df(deck)
assert df["OWC"].values == 2200
assert len(df) == 1
assert "IGNORE1" not in df
deckstr = """
GAS
WATER
EQUIL
2000 200 2200 /
"""
deck = EclFiles.str2deck(deckstr)
df = equil.deck2df(deck)
assert df["GWC"].values == 2200
assert "OWC" not in df
assert len(df) == 1
assert "IGNORE2" not in df
deckstr = """
GAS
OIL
EQUIL
2000 200 2200 1 2100 3 /
"""
deck = EclFiles.str2deck(deckstr)
df = equil.deck2df(deck)
assert df["GOC"].values == 2100
assert "GWC" not in df
assert "OWC" not in df
assert len(df) == 1
assert "IGNORE2" not in df
def test_str2df():
"""Test when we send in a string directly"""
schstr = """
GRUPTREE
'OPWEST' 'OP' /
'OP' 'FIELD' /
'FIELD' 'AREA' /
'AREA' 'NORTHSEA' /
/
WELSPECS
'OP1' 'OPWEST' 41 125 1759.74 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
/
"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck)
assert grupdf.dropna().empty # the DATE is empty
# This is only available if GRUPNET is also there
assert "TERMINAL_PRESSURE" not in grupdf
withstart = gruptree.gruptree2df(deck, startdate="2019-01-01")
assert not withstart.dropna().empty
assert len(withstart) == 5
def test_tstep():
"""Test that we support the TSTEP keyword"""
schstr = """
DATES
1 MAY 2001 /
/
WCONHIST
'OP1' 1000 /
/
TSTEP
1 /
WCONHIST
'OP1' 2000 /
/
TSTEP
2 3 /
WCONHIST
'OP1' 3000 /
/
"""
deck = EclFiles.str2deck(schstr)
wcondf = wcon.df(deck)
dates = [str(x) for x in wcondf["DATE"].unique()]
assert len(dates) == 3
assert "2001-05-01" in dates
assert "2001-05-02" in dates
assert "2001-05-07" in dates
def test_wconhist():
"""Test WCONHIST parsing and column names"""
wconstr = """
WCONHIST
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wconhist_df = wcon.df(deck)
pd.testing.assert_frame_equal(
wconhist_df,
pd.DataFrame([{
"WELL": "FOO",
"STATUS": "0",
"CMODE": "1",
"ORAT": 0,
"WRAT": 0,
"GRAT": 0,
"VFP_TABLE": 0,
"ALQ": 0,
"THP": 0,
"BHP": 0,
"NGLRAT": 0,
"DATE": None,
"KEYWORD": "WCONHIST",
}]),
)
def test_wconinje():
"""Test WCONINJE parsing and column names"""
wconstr = """
WCONINJE
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wconinje_df = wcon.df(deck)
pd.testing.assert_frame_equal(
wconinje_df,
pd.DataFrame([{
"WELL": "FOO",
"TYPE": "0",
"STATUS": "1",
"CMODE": None,
"RATE": None,
"RESV": None,
"BHP": 6895,
"THP": None,
"VFP_TABLE": 0,
"VAPOIL_C": 0,
"GAS_STEAM_RATIO": 0,
"SURFACE_OIL_FRACTION": 0,
"SURFACE_WATER_FRACTION": 0,
"SURFACE_GAS_FRACTION": 0,
"OIL_STEAM_RATIO": 0,
"DATE": None,
"KEYWORD": "WCONINJE",
}]),
)
def test_pvtw():
"""Test that PVTW can be parsed from a string"""
deck = """PVTW
327.3 1.03 4.51E-005 0.25 0 /"""
pvtw_df = pvt.pvtw_fromdeck(EclFiles.str2deck(deck))
pd.testing.assert_frame_equal(
pvtw_df,
pd.DataFrame(
columns=[
"PRESSURE",
"VOLUMEFACTOR",
"COMPRESSIBILITY",
"VISCOSITY",
"VISCOSIBILITY",
"PVTNUM",
],
data=[[327.3, 1.03, 4.51e-005, 0.25, 0.0, 1]],
),
check_like=True,
)
deck = """PVTW
327.3 1.03 4.51E-005 0.25 0 /
300 1 0.0001 0.2 /"""
pvtw_df = pvt.pvtw_fromdeck(
deck) # Must give string, not deck, for NTPVT guessing
assert len(pvtw_df) == 2
# Test emtpy data:
inc = pvt.df2ecl_pvtw(pvt.df(""))
assert "No data" in inc
assert pvt.df(inc).empty
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_prettyprint(tmpdir, mocker, caplog):
""" "Test prettyprinting with multiple dates and both
GRUPTREE and BRANPROP trees"""
schstr = """
DATES
1 JAN 2000 /
/
GRUPTREE
'TMPL_A' 'FIELD'/
/
BRANPROP
'NODE_A' 'FIELD' /
'TMPL_A' 'NODE_A' /
/
NODEPROP
'FIELD' 20 /
'TMPL_A' 2* YES /
/
WELSPECS
'WELL_1' 'TMPL_A' 1 1 1 OIL /
'WELL_2' 'TMPL_B' 1 1 1 OIL /
/
DATES
1 FEB 2000 /
/
NODEPROP
'FIELD' 22 /
/
"""
expected_prettyprint = """
Date: 2000-01-01
GRUPTREE trees:
FIELD
└── TMPL_A
└── WELL_1
TMPL_B
└── WELL_2
BRANPROP trees:
FIELD
└── NODE_A
└── TMPL_A
└── WELL_1
Date: 2000-02-01
BRANPROP trees:
FIELD
└── NODE_A
└── TMPL_A
└── WELL_1
"""
dframe = gruptree.df(EclFiles.str2deck(schstr))
assert gruptree.prettyprint(dframe).strip() == expected_prettyprint.strip()
def test_str2df():
"""Test parsing of a direct string"""
swofstr = """
SWOF
0 0 1 1
1 1 0 0
/
"""
deck = EclFiles.str2deck(swofstr)
satdf = satfunc.deck2df(deck)
assert len(satdf) == 2
swofstr2 = """
-- RUNSPEC -- (this line is optional)
TABDIMS
2 /
-- PROPS -- (optional)
SWOF
0 0 1 1
1 1 0 0
/
0 0 1 1
0.5 0.5 0.5 0.5
1 1 0 0
/
"""
deck2 = EclFiles.str2deck(swofstr2)
satdf2 = satfunc.deck2df(deck2)
assert "SATNUM" in satdf
assert len(satdf2["SATNUM"].unique()) == 2
assert len(satdf2) == 5
# Try empty/bogus data:
bogusdf = satfunc.deck2df("SWRF\n 0 /\n")
# (warnings should be issued)
assert bogusdf.empty
# Test with bogus E100 keywords:
tricky = satfunc.deck2df("FOO\n\nSWOF\n 0 0 0 1/ 1 1 1 0\n/\n")
assert not tricky.empty
assert len(tricky["SATNUM"].unique()) == 1
def test_rock():
"""Test parsing of the ROCK keyword from a string"""
deck = """ROCK
100 1.1 /"""
rock_df = pvt.rock_fromdeck(EclFiles.str2deck(deck))
assert len(rock_df) == 1
assert "PRESSURE" in rock_df
assert "COMPRESSIBILITY" in rock_df
dframe_via_string = pvt.rock_fromdeck(pvt.df2ecl_rock(rock_df))
pd.testing.assert_frame_equal(dframe_via_string, rock_df)
def test_grupnet_rst_docs(tmp_path):
"""Provide the input and output for the examples in the RST documentation"""
os.chdir(tmp_path)
schstr = """
START
01 'JAN' 2000 /
SCHEDULE
GRUPTREE
'OPEAST' 'OP' /
'OPWEST' 'OP' /
'INJEAST' 'WI' /
'OP' 'FIELD' /
'WI' 'FIELD' /
'FIELD' 'AREA' /
'AREA' 'NORTHSEA' /
/
GRUPNET
'FIELD' 90 /
'OPWEST' 100 /
/
WELSPECS
'OP1' 'OPWEST' 41 125 1759.74 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
'OP2' 'OPEAST' 43 122 1776.01 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
'INJ1' 'INJEAST' 33 115 1960.21 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
/
"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck)
grupdf[["DATE", "CHILD", "PARENT", "KEYWORD"]].to_csv("gruptree.csv", index=False)
grupdf.to_csv("gruptreenet.csv", index=False)
grup_dict = gruptree.edge_dataframe2dict(grupdf)
print("Copy and paste into RST files:")
print(str(gruptree.tree_from_dict(grup_dict[0])))
assert (
str(gruptree.tree_from_dict(grup_dict[0])).strip()
== """
NORTHSEA
└── AREA
└── FIELD
├── OP
│ ├── OPEAST
│ │ └── OP2
│ └── OPWEST
│ └── OP1
└── WI
└── INJEAST
└── INJ1
""".strip()
)
def test_emptytree():
"""Test empty schedule sections. Don't want to crash"""
schstr = ""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck)
assert grupdf.empty
gruptreedict = gruptree.df2dict(grupdf)
assert not gruptreedict
treelibtree = gruptree.dict2treelib("", gruptreedict)
treestring = str(treelibtree)
assert not treestring.strip() # Let it return whitespace
def test_str2df():
deckstr = """
FAULTS
'A' 1 2 3 4 5 6 'I' /
'B' 2 3 4 5 6 7 'J' /
/
"""
deck = EclFiles.str2deck(deckstr)
faultsdf = faults.df(deck)
assert len(faultsdf) == 16
def test_str2df():
"""Test making dataframe from a string"""
deckstr = """
FAULTS
'A' 1 2 3 4 5 6 'I' /
'B' 2 3 4 5 6 7 'J' /
/
"""
deck = EclFiles.str2deck(deckstr)
faultsdf = faults.df(deck)
assert len(faultsdf) == 16
def test_branprop_nodeprop(schstr, expected_dframe, check_columns):
"""Testing that the gruptree dataframe works correctly
when the schedule string contains BRANPROP and NODEPROP
"""
deck = EclFiles.str2deck(schstr)
dframe = gruptree.df(deck).reset_index()
expected_dframe.DATE = pd.to_datetime(expected_dframe.DATE)
pd.testing.assert_frame_equal(
dframe[check_columns],
expected_dframe[check_columns],
check_dtype=False,
)
def test_emptytree_strdeck():
"""Test empty schedule sections. Don't want to crash"""
schstr = ""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck)
assert grupdf.empty
gruptreedict = gruptree.edge_dataframe2dict(grupdf)
assert not gruptreedict[0]
treelibtree = gruptree.tree_from_dict(gruptreedict[0])
# Returning an empty string and not a treelib.Tree() is
# a workaround for a limitation in treelib.
assert treelibtree == ""
def test_str2df():
"""Test dataframe extraction from strings"""
wconstr = """
WCONHIST
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
wconstr = """
WCONINJH
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
wconstr = """
WCONINJE
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
wconstr = """
WCONPROD
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
def test_str2df():
wconstr = """
WCONHIST
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
wconstr = """
WCONINJH
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
wconstr = """
WCONINJE
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
wconstr = """
WCONPROD
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wcondf = wcon.deck2df(deck)
assert len(wcondf) == 1
def test_multiplestr2df():
deckstr = """
FAULTS
'A' 1 2 3 4 5 6 'I' /
'B' 2 3 4 5 6 7 'J' /
/
FAULTS
'C' 1 1 3 3 10 15 'I' /
'D' 2 2 4 4 10 10 'J' /
/
"""
deck = EclFiles.str2deck(deckstr)
faultsdf = faults.deck2df(deck).set_index("NAME")
assert len(faultsdf) == 23
assert len(faultsdf.loc[["D"]]) == 1 # Pass lists to .loc for single row
assert len(faultsdf.loc["C"]) == 6
def test_pvtw():
"""Test that PVTW can be parsed from a string"""
deck = """PVTW
327.3 1.03 4.51E-005 0.25 0 /"""
pvtw_df = pvt.pvtw_fromdeck(EclFiles.str2deck(deck))
assert len(pvtw_df) == 1
assert "VOLUMEFACTOR" in pvtw_df
assert "PRESSURE" in pvtw_df
assert "COMPRESSIBILITY" in pvtw_df
assert "VISCOSIBILITY" in pvtw_df
deck = """PVTW
327.3 1.03 4.51E-005 0.25 0 /
300 1 0.0001 0.2 /"""
pvtw_df = pvt.pvtw_fromdeck(
deck) # Must give string, not deck, for NTPVT guessing
assert len(pvtw_df) == 2
def test_equil_fromdeck():
"""equil.df relies on equil.equil_fromdeck, test that expliclitly"""
deckstr = """
OIL
WATER
GAS
EQUIL
-- DATUM PRESSURE OWC PCOWC GOC PCGOC INITRS INITRV ACCURACY
2469.0 382.4 1700.0 0.0 0.0 0.0 1 0 20 /
2469.0 382.4 1000.0 0.0 0.0 0.0 2 0 20 /
"""
pd.testing.assert_frame_equal(equil.equil_fromdeck(deckstr),
equil.df(deckstr).drop("KEYWORD", axis=1))
# If we supply a deck object and not a string, it will not be able
# to pick up both EQLNUMs:
assert len(equil.equil_fromdeck(deckstr)) == 2 # correct
assert len(equil.equil_fromdeck(deckstr, 2)) == 2
assert len(equil.equil_fromdeck(deckstr, 1)) == 1
assert len(equil.equil_fromdeck(
EclFiles.str2deck(deckstr))) == 1 # (watch out!)
wrongdeck = """
EQUIL
1 1 1 1 1 1 1 1 1 /
/
"""
with pytest.raises(ValueError,
match="Could not determine phase configuration"):
equil.equil_fromdeck(wrongdeck)
with pytest.raises(ValueError,
match="Could not determine phase configuration"):
equil.equil_fromdeck("")
# Single phase decks will not work:
gasdeck = """
GAS
EQUIL
1 1 5000 0 4000 /
"""
with pytest.raises(ValueError,
match="Could not determine phase configuration"):
equil.equil_fromdeck(gasdeck)
def test_multiplestr2df():
"""Test that we support multiple occurences of the FAULTS keyword"""
deckstr = """
FAULTS
'A' 1 2 3 4 5 6 'I' /
'B' 2 3 4 5 6 7 'J' /
/
FAULTS
'C' 1 1 3 3 10 15 'I' /
'D' 2 2 4 4 10 10 'J' /
/
"""
deck = EclFiles.str2deck(deckstr)
faultsdf = faults.df(deck).set_index("NAME")
assert len(faultsdf) == 23
assert len(faultsdf.loc[["D"]]) == 1 # Pass lists to .loc for single row
assert len(faultsdf.loc["C"]) == 6
def test_grupnetroot(schstr, expected_dframe, expected_tree):
"""Test that terminal pressure of the tree root can be
included in the dataframe (with an empty parent)"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck, startdate="2000-01-01")
non_default_columns = ["CHILD", "PARENT", "TERMINAL_PRESSURE"]
pd.testing.assert_frame_equal(
grupdf[non_default_columns]
.sort_values(["CHILD", "PARENT"])
.reset_index(drop=True),
expected_dframe.sort_values(["CHILD", "PARENT"]).reset_index(drop=True),
check_dtype=False,
)
treelist = gruptree.edge_dataframe2dict(grupdf)
# Merge strings for all trees (if multiple roots)
strtrees = [str(gruptree.tree_from_dict(tree)) for tree in treelist]
strtrees.sort() # Avoid flaky test due to sorting
treelibtree = "".join(strtrees)
assert treelibtree.strip() == expected_tree.strip()
def test_wconprod():
"""Test WCONPROD parsing and column names"""
wconstr = """
WCONPROD
'FOO' 0 1 /
/
"""
deck = EclFiles.str2deck(wconstr)
wconprod_df = wcon.df(deck)
pd.testing.assert_frame_equal(
wconprod_df,
pd.DataFrame(
[
{
"WELL": "FOO",
"STATUS": "0",
"CMODE": "1",
"ORAT": 0,
"WRAT": 0,
"GRAT": 0,
"LRAT": 0,
"RESV": 0,
"BHP": 1.01325,
"THP": 0,
"VFP_TABLE": 0,
"ALQ": 0,
# These E300 columns should not
# be regarded critical for API.
"E300_ITEM13": None,
"E300_ITEM14": None,
"E300_ITEM15": None,
"E300_ITEM16": None,
"E300_ITEM17": None,
"E300_ITEM18": None,
"E300_ITEM19": None,
"E300_ITEM20": None,
"DATE": None,
"KEYWORD": "WCONPROD",
}
]
),
)
def test_grupnetdf():
schstr = """
GRUPTREE
'OPWEST' 'OP' /
'OP' 'FIELD' /
'FIELD' 'AREA' /
'AREA' 'NORTHSEA' /
/
GRUPNET
'FIELD' 90 /
'OPWEST' 100 /
/
"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.deck2df(deck)
assert "TERMINAL_PRESSURE" in grupdf
assert 90 in grupdf["TERMINAL_PRESSURE"].values
assert 100 in grupdf["TERMINAL_PRESSURE"].values
def test_tstep():
schstr = """
GRUPTREE
'OPWEST' 'OP' /
'OP' 'FIELD' /
'FIELD' 'AREA' /
'AREA' 'NORTHSEA' /
/
TSTEP
1 /
WELSPECS
'OP1' 'OPWEST' 41 125 1759.74 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
/
"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck)
assert len(grupdf["DATE"].unique()) == 2
print(grupdf)
def test_grupnet_rst_docs(tmpdir):
"""Provide the input and output for the examples in the RST documentation"""
tmpdir.chdir()
schstr = """
START
01 'JAN' 2000 /
SCHEDULE
GRUPTREE
'OPEAST' 'OP' /
'OPWEST' 'OP' /
'INJEAST' 'WI' /
'OP' 'FIELD' /
'WI' 'FIELD' /
'FIELD' 'AREA' /
'AREA' 'NORTHSEA' /
/
GRUPNET
'FIELD' 90 /
'OPWEST' 100 /
/
WELSPECS
'OP1' 'OPWEST' 41 125 1759.74 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
'OP2' 'OPEAST' 43 122 1776.01 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
'INJ1' 'INJEAST' 33 115 1960.21 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' /
/
"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck)
grupdf[["DATE", "CHILD", "PARENT", "KEYWORD"]].to_csv("gruptree.csv",
index=False)
grupdf.to_csv("gruptreenet.csv", index=False)
grup_dict = gruptree.df2dict(grupdf)
print("Copy and paste into RST files:")
print(str(gruptree.dict2treelib("", grup_dict[0])))
def test_grupnetdf():
"""Test making a dataframe from a GRUPTREE string"""
schstr = """
GRUPTREE
'OPWEST' 'OP' /
'OP' 'FIELD' /
'WI' 'FIELD' /
'FIELD' 'AREA' /
'AREA' 'NORTHSEA' /
/
GRUPNET
'FIELD' 90 /
'OPWEST' 100 /
/
"""
deck = EclFiles.str2deck(schstr)
grupdf = gruptree.df(deck, startdate="2000-01-01")
print(grupdf)
assert "TERMINAL_PRESSURE" in grupdf
assert 90 in grupdf["TERMINAL_PRESSURE"].values
assert 100 in grupdf["TERMINAL_PRESSURE"].values
def test_sgof_satnuminferrer(tmpdir):
"""Test inferring of SATNUMS in SGOF strings"""
sgofstr = """
SGOF
0 0 1 1
1 1 0 0
/
0 0 1 1
0.5 0.5 0.5 0.5
1 1 0 0
/
0 0 1 0
0.1 0.1 0.1 0.1
1 1 0 0
/
"""
tmpdir.chdir()
assert inferdims.guess_dim(sgofstr, "TABDIMS", 0) == 3
sgofdf = satfunc.deck2df(sgofstr)
assert "SATNUM" in sgofdf
assert len(sgofdf["SATNUM"].unique()) == 3
assert len(sgofdf) == 8
# This illustrates how we cannot do it, CRITICAL
# logging errors will be displayed:
sgofdf = satfunc.deck2df(EclFiles.str2deck(sgofstr))
assert len(sgofdf["SATNUM"].unique()) == 1
# Write to file and try to parse it with command line:
sgoffile = "__sgof_tmp.txt"
with open(sgoffile, "w") as sgof_f:
sgof_f.write(sgofstr)
sys.argv = ["ecl2csv", "satfunc", sgoffile, "-o", sgoffile + ".csv"]
ecl2csv.main()
parsed_sgof = pd.read_csv(sgoffile + ".csv")
assert len(parsed_sgof["SATNUM"].unique()) == 3
def test_pvto_strings():
"""Test PVTO parsing from strings"""
pvto_deck = """PVTO
0 1 1.0001 1
200 1.000 1.001 /
18 25 1.14 0.59 /
/ -- One table (pvtnum=1), two records (two gor's)
"""
dframe = pvt.pvto_fromdeck(EclFiles.str2deck(pvto_deck))
assert "PVTNUM" in dframe
assert "RS" in dframe
assert "PRESSURE" in dframe
assert "VISCOSITY" in dframe
assert "VOLUMEFACTOR" in dframe
assert len(dframe) == 3
assert len(dframe["RS"].unique()) == 2
assert len(dframe["PRESSURE"].unique()) == 3
assert len(dframe["VOLUMEFACTOR"].unique()) == 3
assert len(dframe["VISCOSITY"].unique()) == 3
assert set(dframe["PVTNUM"].values) == {1}
assert max(dframe["PRESSURE"]) == 200
dframe_via_string = pvt.pvto_fromdeck(pvt.df2ecl_pvto(dframe))
pd.testing.assert_frame_equal(dframe_via_string, dframe)
# Provide TABDIMS in first test.. Infer later
pvto_deck = """TABDIMS
1 2 /
PVTO
0 1 1.0001 1
200 1.000 1.001 /
18 25 1.14 0.59 /
/
1 2 1.0001 1
333 1.000 1.001 /
19 30 1.14 0.59 /
/
"""
dframe = pvt.pvto_fromdeck(EclFiles.str2deck(pvto_deck))
assert len(dframe) == 6
assert "PVTNUM" in dframe
assert set(dframe["PVTNUM"].astype(int).unique()) == {1, 2}
assert len(dframe["RS"].unique()) == 4
assert len(dframe["PRESSURE"].unique()) == 6
assert len(dframe["VOLUMEFACTOR"].unique()) == 3
dframe_via_string = pvt.pvto_fromdeck(pvt.df2ecl_pvto(dframe))
pd.testing.assert_frame_equal(dframe_via_string, dframe)
# Now test the same but without TABDIMS:
pvto_deck = """
PVTO
0 1 1.0001 1
200 1.000 1.001 /
18 25 1.14 0.59 /
/
1 2 1.0001 1
333 1.000 1.001 /
19 30 1.14 0.59 /
/
"""
dframe = pvt.pvto_fromdeck(pvto_deck)
assert len(dframe) == 6
assert "PVTNUM" in dframe
assert set(dframe["PVTNUM"].astype(int).unique()) == {1, 2}
assert len(dframe["RS"].unique()) == 4
assert len(dframe["PRESSURE"].unique()) == 6
assert len(dframe["VOLUMEFACTOR"].unique()) == 3
dframe_via_string = pvt.pvto_fromdeck(pvt.df2ecl_pvto(dframe))
pd.testing.assert_frame_equal(dframe_via_string, dframe)
# Test emtpy data:
inc = pvt.df2ecl_pvto(pvt.df(""))
assert "No data" in inc
assert pvt.df(inc).empty
