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'})