def test_restart_runs(self):
base_smry = ESmry(test_path("data/SPE1CASE1.SMSPEC"))
self.assertEqual(base_smry.start_date, datetime.datetime(2015, 1, 1))
time0 = base_smry["TIME"]
self.assertEqual(time0[0], 1.0)
rst_smry1 = ESmry(test_path("data/SPE1CASE1_RST60.SMSPEC"))
time1 = rst_smry1["TIME"]
gor1 = rst_smry1["WGOR:PROD"]
self.assertEqual(rst_smry1.start_date, datetime.datetime(2015, 1, 1))
self.assertEqual(len(rst_smry1), 60)
self.assertEqual(time1[0], 1856.0)
self.assertEqual(len(time1), 60)
self.assertEqual(len(gor1), 60)
rst_smry2 = ESmry(test_path("data/SPE1CASE1_RST60.SMSPEC"),
load_base_run=True)
time2 = rst_smry2["TIME"]
gor2 = rst_smry2["WGOR:PROD"]
self.assertEqual(rst_smry2.start_date, datetime.datetime(2015, 1, 1))
self.assertEqual(len(rst_smry2), 123)
self.assertEqual(time2[0], 1.0)
self.assertEqual(len(rst_smry2), 123)
self.assertEqual(len(time2), 123)
self.assertEqual(len(gor2), 123)
def test_parser_section_deckItems(self):
all_spe1case1 = [
"RUNSPEC", "TITLE", "DIMENS", "EQLDIMS", "TABDIMS", "REGDIMS",
"OIL", "GAS", "WATER", "DISGAS", "FIELD", "START", "WELLDIMS",
"UNIFOUT", "UDQDIMS", "UDADIMS", "GRID", "INIT", "NOECHO", "DX",
"DY", "DZ", "TOPS", "PORO", "PERMX", "PERMY", "PERMZ", "ECHO",
"PROPS", "PVTW", "ROCK", "SWOF", "SGOF", "DENSITY", "PVDG", "PVTO",
"REGIONS", "EQLNUM", "FIPNUM", "SOLUTION", "EQUIL", "RSVD",
"SUMMARY", "FOPR", "WGOR", "FGOR", "BPR", "BGSAT", "WBHP", "WGIR",
"WGIT", "WGPR", "WGPT", "WOIR", "WOIT", "WOPR", "WOPT", "WWIR",
"WWIT", "WWPR", "WWPT", "WUOPRL", "SCHEDULE", "UDQ", "RPTSCHED",
"RPTRST", "DRSDT", "WELSPECS", "COMPDAT", "WCONPROD", "WCONINJE",
"TSTEP"
]
# notice that RUNSPEC keywords will always be parsed since these properties from these keyword
# are needed to parse following sections.
props_spe1case1 = [
"RUNSPEC", "TITLE", "DIMENS", "EQLDIMS", "TABDIMS", "REGDIMS",
"OIL", "GAS", "WATER", "DISGAS", "FIELD", "START", "WELLDIMS",
"UNIFOUT", "UDQDIMS", "UDADIMS", "GRID", "PVTW", "ROCK", "SWOF",
"SGOF", "DENSITY", "PVDG", "PVTO"
]
parser = Parser()
error_recovery = [("PARSE_RANDOM_SLASH", opm.io.action.ignore),
("PARSE_EXTRA_RECORDS", opm.io.action.ignore)]
context = ParseContext(error_recovery)
deck1 = parser.parse(test_path("data/SPE1CASE1.DATA"), context)
self.assertEqual(len(deck1), len(all_spe1case1))
test_1 = [dkw.name for dkw in deck1]
for test, ref in zip(test_1, all_spe1case1):
self.assertEqual(test, ref)
section_list = [eclSectionType.PROPS]
deck2 = parser.parse(test_path("data/SPE1CASE1.DATA"), context,
section_list)
self.assertEqual(len(deck2), len(props_spe1case1))
test_2 = [dkw.name for dkw in deck2]
for test, ref in zip(test_2, props_spe1case1):
self.assertEqual(test, ref)
# props section keyword located in include file for this deck (SPE1CASE1B.DATA)
# not possible to parse individual sections
with self.assertRaises(RuntimeError):
parser.parse(test_path("data/SPE1CASE1B.DATA"), context,
section_list)
def test_arrays(self):
refList = [
"INTEHEAD", "LOGIHEAD", "DOUBHEAD", "PORV", "DEPTH", "DX", "DY",
"DZ", "PORO", "PERMX", "PERMY", "PERMZ", "NTG", "TRANX", "TRANY",
"TRANZ", "TABDIMS", "TAB", "ACTNUM", "EQLNUM", "FIPNUM", "PVTNUM",
"SATNUM", "TRANNNC"
]
self.assertRaises(RuntimeError, EclFile, "/file/that/does_not_exists")
file2uf = EclFile(test_path("data/SPE9.INIT"), preload=False)
self.assertEqual(len(file2uf), 24)
arr_string_list = [x[0] for x in file2uf.arrays]
self.assertEqual(arr_string_list, refList)
file2f = EclFile(test_path("data/SPE9.FINIT"))
self.assertEqual(len(file2f), 24)
self.assertTrue(isinstance(file2uf.arrays, list))
self.assertEqual(len(file2uf.arrays), len(refList))
for str1, str2 in zip(file2uf.arrays, refList):
self.assertEqual(str1[0], str2)
self.assertEqual(file2uf.arrays[3], ("PORV", eclArrType.REAL, 9000))
self.assertEqual(file2uf.arrays[16], ("TABDIMS", eclArrType.INTE, 100))
self.assertEqual(file2uf.arrays[17], ("TAB", eclArrType.DOUB, 885))
def test_load(self):
tv = TimeVector(datetime.date(1997, 11, 6),
base_file=test_path("data/schedule/part1.sch"))
tv.load(test_path("data/schedule/part3.sch"))
tv.load(test_path("data/schedule/fragment_dates.sch"))
tv.load(test_path("data/schedule/part2.sch"))
self.assertEqual(tv.dates, [
datetime.datetime(1997, 11, 6),
datetime.datetime(1997, 11, 14, 0, 0, 0, 1000),
datetime.datetime(1997, 12, 1),
datetime.datetime(1997, 12, 17),
datetime.datetime(1998, 1, 1),
datetime.datetime(1998, 2, 1),
datetime.datetime(1998, 3, 1),
datetime.datetime(1998, 3, 29),
datetime.datetime(1998, 3, 30),
datetime.datetime(1998, 4, 1),
datetime.datetime(1998, 4, 23),
datetime.datetime(1998, 5, 1),
datetime.datetime(1998, 5, 26),
datetime.datetime(1998, 5, 27),
datetime.datetime(1998, 6, 1),
datetime.datetime(1998, 8, 1)
])
def setUpClass(cls):
parser = Parser()
cls.deck_cpa = parser.parse(test_path('data/CORNERPOINT_ACTNUM.DATA'))
cls.cp_state = EclipseState(cls.deck_cpa)
cls.deck_spe3 = parser.parse(test_path('spe3/SPE3CASE1.DATA'))
cls.state = EclipseState(cls.deck_spe3)
cls.schedule = Schedule(cls.deck_spe3, cls.state)
cls.summary_config = SummaryConfig(cls.deck_spe3, cls.state, cls.schedule)
def test_str(self):
tv = TimeVector(datetime.date(1997, 11, 6),
base_string=open(
test_path("data/schedule/part1.sch")).read())
tv.load(test_path("data/schedule/part3.sch"))
tv.load(test_path("data/schedule/part2.sch"))
s = str(tv)
tv2 = TimeVector(datetime.date(1997, 11, 6))
tv2.load_string(s, date=datetime.datetime(1997, 11, 6))
for ts1, ts2 in zip(tv, tv2):
self.assertEqual(ts1.dt, ts2.dt)
def test_base_runs(self):
with self.assertRaises(RuntimeError):
ESmry("/file/that/does_not_exists")
smry1 = ESmry(test_path("data/SPE1CASE1.SMSPEC"))
self.assertEqual(len(smry1), 67)
self.assertEqual(smry1.start_date, datetime.datetime(2015, 1, 1))
self.assertEqual(smry1.end_date, datetime.datetime(2020, 4, 29))
self.assertTrue("TIME" in smry1)
self.assertTrue("BPR:10,10,3" in smry1)
self.assertFalse("XXXX" in smry1)
with self.assertRaises(ValueError):
test = smry1["XXX"]
time1a = smry1["TIME"]
self.assertEqual(len(time1a), len(smry1))
time1b = smry1["TIME", True]
self.assertEqual(len(time1b), 64)
def test_content(self):
refContent = [('PROD', (2015, 1, 1), 0.0), ('INJ', (2015, 1, 1), 0.0),
('A-1H', (2015, 9, 1), 243.0),
('B-2H', (2016, 5, 31), 516.0),
('PROD', (2017, 7, 31), 942.0)]
with self.assertRaises(ValueError):
ERft("/file/that/does_not_exists")
rft1 = ERft(test_path("data/SPE1CASE1.RFT"))
self.assertEqual(len(rft1), 5)
self.assertTrue(("PROD", 2015, 1, 1) in rft1)
self.assertFalse(("XXX", 2015, 1, 1) in rft1)
self.assertTrue(("PRESSURE", "PROD", 2015, 1, 1) in rft1)
self.assertFalse(("XXX", "PROD", 2015, 1, 1) in rft1)
self.assertTrue(("PRESSURE", 0) in rft1)
self.assertTrue(("PRESSURE", 1) in rft1)
self.assertFalse(("XXX", 0) in rft1)
with self.assertRaises(ValueError):
self.assertTrue(("PRESSURE", "XX", "XX") in rft1)
rftlist = rft1.list_of_rfts
self.assertEqual(len(rftlist), 5)
for n, rftdata in enumerate(rftlist):
self.assertEqual(rftdata[0], refContent[n][0])
self.assertEqual(rftdata[1], refContent[n][1])
self.assertEqual(rftdata[2], refContent[n][2])
def setUpClass(cls):
deck = Parser().parse(test_path('spe3/SPE3CASE1.DATA'))
print("Creating state")
cls.state = EclipseState(deck)
print("State OK")
cls.sch = Schedule(deck, cls.state)
cls.timesteps = cls.sch.timesteps
def test_coordinates(self):
Xref = [
2899.45166015625, 2999.390869140625, 2899.45166015625,
2999.390869140625, 2899.4176237656716, 2999.3568089317187,
2899.417623015281, 2999.356808099622
]
Yref = [
2699.973388671875, 2699.973388671875, 2799.969482421875,
2799.969482421875, 2699.9818918149376, 2699.9818918149376,
2799.978009571257, 2799.9780095915808
]
Zref = [
2565.301025390625, 2568.791015625, 2564.42822265625,
2567.918212890625, 2575.29443359375, 2578.784423828125,
2574.421875, 2577.911865234375
]
grid1 = EGrid(test_path("data/9_EDITNNC.EGRID"))
X1, Y1, Z1 = grid1.xyz_from_ijk(9, 7, 0)
for n in range(0, 8):
self.assertAlmostEqual(Xref[n], X1[n], 8)
self.assertAlmostEqual(Yref[n], Y1[n], 8)
self.assertAlmostEqual(Zref[n], Z1[n], 8)
actInd = grid1.active_index(9, 7, 0)
X2, Y2, Z2 = grid1.xyz_from_active_index(actInd)
for n in range(0, 8):
self.assertAlmostEqual(Xref[n], X2[n], 8)
self.assertAlmostEqual(Yref[n], Y2[n], 8)
self.assertAlmostEqual(Zref[n], Z2[n], 8)
def test_paramers(self):
mod1 = EModel(test_path("data/9_EDITNNC.INIT"))
self.assertFalse("XXX" in mod1)
self.assertTrue("PORV" in mod1)
self.assertTrue("PRESSURE" in mod1)
self.assertTrue("RS" in mod1)
self.assertTrue("RV" in mod1)
self.assertEqual(mod1.active_report_step(), 0)
rsteps = mod1.get_report_steps()
self.assertEqual(rsteps, [0, 4, 7, 10, 15, 20, 27, 32, 36, 39])
mod1.set_report_step(7)
# parameter RS and RV is missing in report step number 7
self.assertFalse("RS" in mod1)
self.assertFalse("RV" in mod1)
mod1.set_report_step(15)
self.assertTrue("RS" in mod1)
self.assertTrue("RV" in mod1)
arrayList = mod1.get_list_of_arrays()
def test_write_lists(self):
intList = [1, 2, 3, 4, 5, 6]
boolList = [True, True, False, True]
strList = ["A-1H", "A-2H", "A-3H"]
testFile = "data/TMP.DAT"
outFile = test_path(testFile)
out1 = EclOutput(outFile)
out1.write("ARR1", intList)
out1.write("ARR2", boolList)
out1.write("ARR3", strList)
file1 = EclFile(outFile)
arr1 = file1["ARR1"]
arr2 = file1["ARR2"]
arr3 = file1["ARR3"]
self.assertEqual(len(arr1), len(intList))
self.assertEqual(len(arr2), len(boolList))
self.assertEqual(len(arr3), len(strList))
for v1, v2 in zip(arr1, intList):
self.assertEqual(v1, v2)
for v1, v2 in zip(arr2, boolList):
self.assertEqual(v1, v2)
for v1, v2 in zip(arr3, strList):
self.assertEqual(v1, v2)
if os.path.isfile(testFile):
os.remove(testFile)
def test_keylist(self):
ref_key_list = [
"BPR:1,1,1", "BPR:10,10,3", "FGOR", "FOPR", "TIME", "WBHP:INJ",
"WBHP:PROD", "WGIR:INJ", "WGIR:PROD", "WGIT:INJ", "WGIT:PROD",
"WGOR:PROD", "WGPR:INJ", "WGPR:PROD", "WGPT:INJ", "WGPT:PROD",
"WOIR:INJ", "WOIR:PROD", "WOIT:INJ", "WOIT:PROD", "WOPR:INJ",
"WOPR:PROD", "WOPT:INJ", "WOPT:PROD", "WWIR:INJ", "WWIR:PROD",
"WWIT:INJ", "WWIT:PROD", "WWPR:INJ", "WWPR:PROD", "WWPT:INJ",
"WWPT:PROD"
]
ref_keys_pattern = [
"WGPR:INJ", "WGPR:PROD", "WOPR:INJ", "WOPR:PROD", "WWPR:INJ",
"WWPR:PROD"
]
smry1 = ESmry(test_path("data/SPE1CASE1.SMSPEC"))
list_of_keys = smry1.keys()
self.assertEqual(len(list_of_keys), len(ref_key_list))
for key, ref_key in zip(list_of_keys, ref_key_list):
self.assertEqual(key, ref_key)
for key in list_of_keys:
data = smry1[key]
self.assertEqual(len(smry1), len(data))
list_of_keys2 = smry1.keys("W?PR:*")
self.assertEqual(len(list_of_keys2), len(ref_keys_pattern))
for key, ref in zip(list_of_keys2, ref_keys_pattern):
self.assertEqual(key, ref)
def test_getitem(self):
rst1 = ERst(test_path("data/SPE9.UNRST"))
# get first occurrence of ZWEL, report step 37
zwel1 = rst1[11, 37]
zwel2 = rst1["ZWEL",37, 0]
zwel3 = rst1["ZWEL",37]
for v1,v2 in zip (zwel1, zwel2):
self.assertEqual(v1, v2)
for v1,v2 in zip (zwel1, zwel3):
self.assertEqual(v1, v2)
self.assertEqual(len(zwel1), 78)
self.assertEqual(zwel1[0], "INJE1")
self.assertEqual(zwel1[3], "PRODU2")
self.assertEqual(zwel1[6], "PRODU3")
# get first occurrence of INTEHEAD, report step 37
inteh = rst1["INTEHEAD",37]
self.assertEqual(len(inteh), 411)
self.assertTrue(isinstance(inteh, np.ndarray))
self.assertEqual(inteh.dtype, "int32")
self.assertEqual(inteh[1], 201702)
self.assertEqual(inteh[9], 25)
self.assertEqual(inteh[64], 6)
self.assertEqual(inteh[65], 1)
self.assertEqual(inteh[66], 2016)
# get first occurrence of PRESSURE, report step 74
pres74 = rst1["PRESSURE",74]
self.assertTrue(isinstance(pres74, np.ndarray))
self.assertEqual(pres74.dtype, "float32")
self.assertEqual(len(pres74), 9000)
self.assertAlmostEqual(pres74[0], 2290.9192, 4)
self.assertAlmostEqual(pres74[1], 2254.6619, 4)
self.assertAlmostEqual(pres74[2], 2165.5347, 4)
self.assertAlmostEqual(pres74[3], 1996.2598, 4)
xcon = rst1["XCON", 74]
self.assertTrue(isinstance(xcon, np.ndarray))
self.assertEqual(xcon.dtype, "float64")
self.assertEqual(len(xcon), 7540)
self.assertAlmostEqual(xcon[1], -22.841887080742975, 10)
logih = rst1["LOGIHEAD", 74]
self.assertTrue(isinstance(logih, np.ndarray))
self.assertEqual(len(logih), 121)
for b1, b2 in zip([True, True, False, False, False], logih[0:5]):
self.assertEqual(b1, b2)
def test_get_function_float(self):
file1 = EclFile(test_path("data/SPE9.INIT"))
dzList = [
20.0, 15.0, 26.0, 15.0, 16.0, 14.0, 8.0, 8.0, 18.0, 12.0, 19.0,
18.0, 20.0, 50.0, 100.0
]
poroList = [
0.087, 0.097, 0.111, 0.16, 0.13, 0.17, 0.17, 0.08, 0.14, 0.13,
0.12, 0.105, 0.12, 0.116, 0.157
]
ft3_to_bbl = 0.1781076
refporv = []
for poro, dz in zip(dzList, poroList):
for i in range(0, 600):
refporv.append(300.0 * 300.0 * dz * poro * ft3_to_bbl)
self.assertTrue("PORV" in file1)
porv_index = array_index(file1, "PORV")[0]
porv_np = file1[porv_index]
self.assertEqual(len(porv_np), 9000)
self.assertTrue(isinstance(porv_np, np.ndarray))
self.assertEqual(porv_np.dtype, "float32")
porv_list = file1[porv_index]
for val1, val2 in zip(porv_np, refporv):
self.assertLess(abs(1.0 - val1 / val2), 1e-6)
def test_list_of_arrays(self):
refArrList = ["SEQNUM", "INTEHEAD", "LOGIHEAD", "DOUBHEAD", "IGRP", "SGRP", "XGRP", "ZGRP", "IWEL",
"SWEL","XWEL","ZWEL", "ICON", "SCON", "XCON", "STARTSOL","PRESSURE", "RS", "SGAS", "SWAT", "ENDSOL"]
rst1 = ERst(test_path("data/SPE9.UNRST"))
array_list_74=rst1.arrays(74)
self.assertEqual(len(refArrList), len(array_list_74) )
for n, (name, arrType, arrSize) in enumerate(array_list_74):
self.assertEqual(name, refArrList[n])
if arrType != eclArrType.MESS:
array = rst1[name, 74]
self.assertEqual(len(array), arrSize)
if arrType == eclArrType.INTE:
self.assertEqual(array.dtype, "int32")
elif arrType == eclArrType.REAL:
self.assertEqual(array.dtype, "float32")
elif arrType == eclArrType.DOUB:
self.assertEqual(array.dtype, "float64")
elif arrType == eclArrType.LOGI:
self.assertEqual(array.dtype, "bool")
elif arrType == eclArrType.CHAR:
self.assertTrue(isinstance(array, list))
def test_get_occurence(self):
file1 = EclFile(test_path("data/SPE9.UNRST"))
self.assertTrue("PRESSURE" in file1)
with self.assertRaises(RuntimeError):
test = file1["PRESSURE", int(10)]
#first occurence of pressure
pres = file1["PRESSURE"]
pres0 = file1["PRESSURE", 0]
self.assertEqual(len(pres), len(pres0))
for v1, v2 in zip(pres, pres0):
self.assertEqual(v1, v2)
#occurence number 2 of pressure
pres2 = file1["PRESSURE", 1]
self.assertTrue(isinstance(pres2, np.ndarray))
self.assertEqual(pres2.dtype, "float32")
self.assertEqual(len(pres2), 9000)
seqn0 = file1["SEQNUM", 0]
self.assertEqual(seqn0[0], 37)
seqn1 = file1["SEQNUM", 1]
self.assertEqual(seqn1[0], 74)
self.assertEqual(file1.count("PRESSURE"), 2)
self.assertEqual(file1.count("XXXX"), 0)
def test_hc_filter(self):
nAct_hc_eqln1 = 1090
nAct_hc_eqln2 = 1694
mod1 = EModel(test_path("data/9_EDITNNC.INIT"))
porv = mod1.get("PORV")
mod1.set_depth_fwl([2645.21, 2685.21])
mod1.add_hc_filter()
porv = mod1.get("PORV")
self.assertEqual(len(porv), nAct_hc_eqln1 + nAct_hc_eqln2)
mod1.reset_filter()
mod1.add_filter("EQLNUM","eq", 1);
mod1.add_filter("DEPTH","lt", 2645.21);
porv1 = mod1.get("PORV")
self.assertEqual(len(porv1), nAct_hc_eqln1)
mod1.reset_filter()
mod1.add_filter("EQLNUM","eq", 2);
mod1.add_filter("DEPTH","lt", 2685.21);
porv2 = mod1.get("PORV")
self.assertEqual(len(porv2), nAct_hc_eqln2)
ivect = mod1.get("I")
def setUp(self):
parser = Parser()
deck = parser.parse(test_path('spe3/SPE3CASE1.DATA'))
int_array = np.ones(324)
actnum_kw = DeckKeyword(parser["ACTNUM"], int_array)
deck.add(actnum_kw)
self.spe3 = EclipseState(deck)
self.props = self.spe3.field_props()
def test_well_names(self):
deck = Parser().parse(test_path('spe3/SPE3CASE1.DATA'))
state = EclipseState(deck)
sch = Schedule(deck, state)
wnames = sch.well_names("*")
self.assertTrue("PROD" in wnames)
self.assertTrue("INJ" in wnames)
self.assertEqual(len(wnames), 2)
def test_parser_deckItems(self):
parser = Parser()
error_recovery = [("PARSE_RANDOM_SLASH", opm.io.action.ignore),
("PARSE_EXTRA_RECORDS", opm.io.action.ignore)]
context = ParseContext(error_recovery)
self.deck_spe1case1 = parser.parse(test_path("data/SPE1CASE1.DATA"),
context)
dkw_compdate = self.deck_spe1case1["COMPDAT"]
self.assertTrue(dkw_compdate[0][0].is_string())
self.assertFalse(dkw_compdate[0][1].is_string())
self.assertTrue(dkw_compdate[0][1].is_int())
self.assertFalse(dkw_compdate[0][1].is_double())
self.assertTrue(dkw_compdate[0][8].is_double())
self.assertTrue(dkw_compdate[0][0].value == "PROD")
conI = dkw_compdate[0][1].value
conJ = dkw_compdate[0][2].value
conK = dkw_compdate[0][3].value
self.assertEqual(dkw_compdate[0][5].value, "OPEN")
self.assertTrue((conI, conJ, conK) == (10, 10, 3))
self.assertFalse(dkw_compdate[0][7].valid)
self.assertTrue(dkw_compdate[0][7].defaulted)
self.assertEqual(dkw_compdate[0][6].value, 0)
self.assertEqual(dkw_compdate[0][8].value, 0.5)
dkw_wconprod = self.deck_spe1case1["WCONPROD"]
welln = dkw_wconprod[0][0].value
self.assertEqual(dkw_wconprod[0][2].value, "ORAT")
self.assertEqual(dkw_wconprod[0][3].value, "WUOPRL")
self.assertEqual(dkw_wconprod[0][5].value, 1.5e5)
dkw_permx = self.deck_spe1case1["PERMX"]
permx = dkw_permx.get_raw_array()
self.assertEqual(len(permx), 300)
self.assertTrue(isinstance(permx, np.ndarray))
self.assertEqual(permx.dtype, "float64")
dkw_eqlnum = self.deck_spe1case1["EQLNUM"]
eqlnum = dkw_eqlnum.get_int_array()
self.assertEqual(len(eqlnum), 300)
self.assertTrue(isinstance(eqlnum, np.ndarray))
self.assertEqual(eqlnum.dtype, "int32")
def test_optional(self):
tv = TimeVector(datetime.date(1997, 11, 6),
base_file=test_path("data/schedule/part1.sch"))
# Must have a starting date, either as first keyword in loaded file,
# or alternatively as the optional date argument.
with self.assertRaises(ValueError):
tv.load(test_path("data/schedule/fragment.sch"))
with self.assertRaises(ValueError):
tv.load(test_path("data/schedule/fragment_dates.sch"),
date=datetime.datetime(1998, 1, 1))
tv.load(test_path("data/schedule/fragment.sch"),
date=datetime.datetime(1998, 1, 10))
ts = tv[-1]
self.assertEqual(ts.dt, datetime.datetime(1998, 1, 10))
self.assertEqual(ts.keywords[0].name, "WCONINJE")
def test_grid_props(self):
mod1 = EModel(test_path("data/9_EDITNNC.INIT"))
nI,nJ,nK = mod1.grid_dims()
self.assertEqual((nI,nJ,nK), (13, 22, 11))
nAct = mod1.active_cells()
self.assertEqual(nAct, 2794)
def test_arrays(self):
refList = [
"INTEHEAD", "LOGIHEAD", "DOUBHEAD", "PORV", "DEPTH", "DX", "DY",
"DZ", "PORO", "PERMX", "PERMY", "PERMZ", "NTG", "TRANX", "TRANY",
"TRANZ", "TABDIMS", "TAB", "ACTNUM", "EQLNUM", "FIPNUM", "PVTNUM",
"SATNUM", "TRANNNC"
]
self.assertRaises(ValueError, EclFile, "/file/that/does_not_exists")
file2uf = EclFile(test_path("data/SPE9.INIT"), preload=False)
self.assertEqual(len(file2uf), 24)
arrList = [x[0] for x in file2uf.arrays]
self.assertEqual(arrList, refList)
file2f = EclFile(test_path("data/SPE9.FINIT"))
self.assertEqual(len(file2f), 24)
def test_user_test(self):
tv = TimeVector(datetime.date(1999, 12, 31))
tv.load(test_path('data/schedule/TEMPLATE.SCH'),
date=datetime.datetime(1999, 12, 31))
self.assertListEqual(tv.dates, [
datetime.datetime(1999, 12, 31),
datetime.datetime(2000, 1, 1),
datetime.datetime(2000, 2, 1),
datetime.datetime(2000, 3, 1)
])
def test_no_leading_DATES(self):
tv = TimeVector(datetime.date(1997, 11, 6),
base_file=test_path("data/schedule/part1.sch"))
s = str(tv)
d = Parser().parse_string(s)
kw0 = d[0]
self.assertEqual(kw0.name, "WELSPECS")
tv2 = TimeVector(datetime.date(2000, 1, 1))
self.assertEqual("", str(tv2))
def test_getitem(self):
deck = Parser().parse(test_path('spe3/SPE3CASE1.DATA'))
state = EclipseState(deck)
sch = Schedule(deck, state)
self.assertEqual(len(sch), 176)
with self.assertRaises(IndexError):
a = sch[200]
st100 = sch[100]
nupcol = st100.nupcol
def test_open_shut(self):
deck = Parser().parse(test_path('spe3/SPE3CASE1.DATA'))
state = EclipseState(deck)
sch = Schedule(deck, state)
prod = sch.get_well("PROD", 1)
self.assertEqual(prod.status(), "OPEN")
sch.shut_well("PROD", 10)
prod = sch.get_well("PROD", 10)
self.assertEqual(prod.status(), "SHUT")
def test_get_function_char(self):
file1 = EclFile(test_path("data/9_EDITNNC.SMSPEC"))
self.assertTrue("KEYWORDS" in file1)
kw_index = array_index(file1, "KEYWORDS")[0]
keyw = file1[kw_index]
self.assertEqual(len(keyw), 312)
self.assertEqual(keyw[0], "TIME")
self.assertEqual(keyw[16], "FWCT")
def test_list_of_array(self):
refArrList = [
"TIME", "DATE", "WELLETC", "CONIPOS", "CONJPOS", "CONKPOS",
"HOSTGRID", "DEPTH", "PRESSURE", "SWAT", "SGAS"
]
rft1 = ERft(test_path("data/SPE1CASE1.RFT"))
rft_date = (2016, 5, 31)
arrList1 = rft1.arrays("B-2H", rft_date)
arrList2 = rft1.arrays(3)
self.assertEqual(len(arrList1), len(refArrList))
for n, (name, arrType, arrSize) in enumerate(arrList1):
self.assertEqual(name, refArrList[n])
if arrType != eclArrType.MESS:
array = rft1[name, "B-2H", 2016, 5, 31]
self.assertEqual(len(array), arrSize)
if arrType == eclArrType.INTE:
self.assertEqual(array.dtype, "int32")
elif arrType == eclArrType.REAL:
self.assertEqual(array.dtype, "float32")
elif arrType == eclArrType.DOUB:
self.assertEqual(array.dtype, "float64")
elif arrType == eclArrType.LOGI:
self.assertEqual(array.dtype, "bool")
elif arrType == eclArrType.CHAR:
self.assertTrue(array.dtype.kind in {'U', 'S'})
self.assertEqual(len(arrList2), len(refArrList))
for n, (name, arrType, arrSize) in enumerate(arrList2):
self.assertEqual(name, refArrList[n])
if arrType != eclArrType.MESS:
array = rft1[name, "B-2H", 2016, 5, 31]
self.assertEqual(len(array), arrSize)
if arrType == eclArrType.INTE:
self.assertEqual(array.dtype, "int32")
elif arrType == eclArrType.REAL:
self.assertEqual(array.dtype, "float32")
elif arrType == eclArrType.DOUB:
self.assertEqual(array.dtype, "float64")
elif arrType == eclArrType.LOGI:
self.assertEqual(array.dtype, "bool")
elif arrType == eclArrType.CHAR:
self.assertTrue(array.dtype.kind in {'U', 'S'})
