def test_create(self): parser = Parser() deck = parser.parse(self.spe3fn) context = ParseContext() deck = parser.parse(self.spe3fn, context) with open(self.spe3fn) as f: string = f.read() deck = parser.parse_string(string) deck = parser.parse_string(string, context)
def test_create(self): parser = Parser() deck = parser.parse(self.spe3fn) active_unit_system = deck.active_unit_system() default_unit_system = deck.default_unit_system() self.assertEqual(active_unit_system.name, "Field") context = ParseContext() deck = parser.parse(self.spe3fn, context) with open(self.spe3fn) as f: string = f.read() deck = parser.parse_string(string) deck = parser.parse_string(string, context)
def test_pyinput(self): parser = Parser() deck = parser.parse_string(self.MANUALDATA) with self.assertRaises(ValueError): kw = parser["NOT_A_VALID_KEYWORD"] kw = parser["FIELD"] assert (kw.name == "FIELD")
def test_faults(self): self.assertEquals([], self.state.faultNames()) parser = Parser() faultdeck = parser.parse_string(self.FAULTS_DECK) faultstate = EclipseState(faultdeck) self.assertEqual(['F1', 'F2'], faultstate.faultNames()) # 'F2' 5 5 1 4 1 4 'X-' / \n" f2 = faultstate.faultFaces('F2') self.assertTrue((4, 0, 0, 'X-') in f2) self.assertFalse((3, 0, 0, 'X-') in f2)
def test_dynamic_parser2(self): parser = Parser(add_default=False) builtin = Builtin() kw_list = [ "START", "RUNSPEC", "FIELD", "REGIONS", "DIMENS", "GRID", "DX", "DY", "DZ", "TOPS", "OPERNUM", "FIPNUM" ] for kw in kw_list: parser.add_keyword(builtin[kw]) deck = parser.parse_string(self.REGIONDATA)
def test_jfunc(self): # jf["FLAG"] = WATER; # set in deck # jf["DIRECTION"] = XY; # default # jf["ALPHA_FACTOR"] = 0.5 # default # jf["BETA_FACTOR"] = 0.5 # default # jf["OIL_WATER"] = 21.0 # set in deck # jf["GAS_OIL"] = -1.0 # N/A parser = Parser() deck = parser.parse(test_path('data/JFUNC.DATA')) js = EclipseState(deck) self.assertEqual('JFUNC TEST', js.title) jf = js.jfunc() print(jf) self.assertEqual(jf['FLAG'], 'WATER') self.assertEqual(jf['DIRECTION'], 'XY') self.assertFalse('GAS_OIL' in jf) self.assertTrue('OIL_WATER' in jf) self.assertEqual(jf['OIL_WATER'], 21.0) self.assertEqual(jf["ALPHA_FACTOR"], 0.5) # default self.assertEqual(jf["BETA_FACTOR"], 0.5) # default jfunc_gas = """ DIMENS 10 10 10 / ENDSCALE / GRID DX 1000*0.25 / DY 1000*0.25 / DZ 1000*0.25 / TOPS 100*0.25 / PORO 1000*0.15 / JFUNC GAS * 13.0 0.6 0.7 Z / PROPS\nREGIONS """ deck2 = parser.parse_string(jfunc_gas) js_gas = EclipseState(deck2) jf = js_gas.jfunc() self.assertEqual(jf['FLAG'], 'GAS') self.assertEqual(jf['DIRECTION'], 'Z') self.assertTrue('GAS_OIL' in jf) self.assertFalse('OIL_WATER' in jf) self.assertEqual(jf['GAS_OIL'], 13.0) self.assertEqual(jf["ALPHA_FACTOR"], 0.6) # default self.assertEqual(jf["BETA_FACTOR"], 0.7) # default
def test_parse_ignore_keyword(self): deck_string = """ FIPNUM 100*1 100*2 / KEYWORD 1 2 3 / """ parse_context = ParseContext() parser = Parser() parse_context.ignore_keyword("KEYWORD") deck = parser.parse_string(deck_string, parse_context) self.assertEqual(len(deck), 1)
def test_parser_extension(self): error_recovery = [("PARSE_RANDOM_SLASH", opm.io.action.ignore)] parse_context = ParseContext(error_recovery) parser = Parser() for kw in self.KEYWORDS: parser.add_keyword(json.dumps(kw)) deck = parser.parse_string(self.DECK_ADDITIONAL_KEYWORDS, parse_context) self.assertIn('TESTKEY0', deck) self.assertIn('TESTKEY1', deck) self.assertIn('TESTKEY2', deck)
def test_dynamic_parser(self): parser = Parser(add_default=False) builtin = Builtin() parser.add_keyword(builtin.START) parser.add_keyword(builtin.RUNSPEC) parser.add_keyword(builtin.FIELD) parser.add_keyword(builtin.DIMENS) parser.add_keyword(builtin.GRID) parser.add_keyword(builtin.DX) parser.add_keyword(builtin.DY) parser.add_keyword(builtin.DZ) parser.add_keyword(builtin.TOPS) parser.add_keyword(builtin.REGIONS) parser.add_keyword(builtin.OPERNUM) parser.add_keyword(builtin.FIPNUM) deck = parser.parse_string(self.REGIONDATA)
def test_raw_string_output(self): deck_string = """ UDQ DEFINE WUOPR2 WOPR '*' * WOPR '*' / DEFINE WUGASRA 3 - WGLIR '*' / / """ parse_context = ParseContext( ) parser = Parser() parse_context.ignore_keyword("KEYWORD") deck = parser.parse_string( deck_string ) udq = deck[0] s = "" for rec in udq: for item in rec: s += item.get_str(0)
def test_deck_kw_vector(self): parser = Parser() deck = parser.parse_string(self.REGIONDATA) active_unit_system = deck.active_unit_system() default_unit_system = deck.default_unit_system() self.assertEqual(active_unit_system.name, "Field") int_array = np.array([0, 1, 2, 3]) hbnum_kw = DeckKeyword( parser["HBNUM"], int_array) assert( np.array_equal(hbnum_kw.get_int_array(), int_array) ) raw_array = np.array([1.1, 2.2, 3.3]) zcorn_kw = DeckKeyword( parser["ZCORN"], raw_array, active_unit_system, default_unit_system) assert( np.array_equal(zcorn_kw.get_raw_array(), raw_array) ) si_array = zcorn_kw.get_SI_array() self.assertAlmostEqual( si_array[0], 1.1 * unit_foot ) self.assertAlmostEqual( si_array[2], 3.3 * unit_foot )
def test_deck_kw_records_uda(self): parser = Parser() deck = parser.parse_string(self.REGIONDATA) active_unit_system = deck.active_unit_system() default_unit_system = deck.default_unit_system() oil_target = 30000 # stb/day well_name = "PROD" well_status = "OPEN" control_mode = "ORAT" bhp_limit = 1000 # psia wconprod = DeckKeyword(parser["WCONPROD"], [[ well_name, well_status, control_mode, oil_target, "4*", bhp_limit ]], active_unit_system, default_unit_system) self.assertEqual(len(wconprod), 1) record = wconprod[0] self.assertEqual(record[0].name(), "WELL") self.assertTrue(record[0].is_string()) self.assertEqual(record[0].get_str(0), "PROD") self.assertEqual(record[1].name(), "STATUS") self.assertTrue(record[1].is_string()) self.assertEqual(record[1].get_str(0), "OPEN") self.assertEqual(record[2].name(), "CMODE") self.assertTrue(record[2].is_string()) self.assertEqual(record[2].get_str(0), "ORAT") self.assertEqual(record[3].name(), "ORAT") self.assertTrue(record[3].is_uda()) self.assertEqual(record[3].value, 30000) self.assertEqual(record[4].name(), "WRAT") self.assertTrue(record[4].is_uda()) self.assertEqual(record[4].value, 0) self.assertEqual(record[5].name(), "GRAT") self.assertTrue(record[5].is_uda()) self.assertEqual(record[5].value, 0) self.assertEqual(record[6].name(), "LRAT") self.assertTrue(record[6].is_uda()) self.assertEqual(record[6].value, 0) self.assertEqual(record[7].name(), "RESV") self.assertTrue(record[7].is_uda()) self.assertEqual(record[7].value, 0) self.assertEqual(record[8].name(), "BHP") self.assertTrue(record[8].is_uda()) self.assertEqual(record[8].value, 1000)
def test_deck_kw_records(self): parser = Parser() deck = parser.parse_string(self.REGIONDATA) active_unit_system = deck.active_unit_system() default_unit_system = deck.default_unit_system() self.assertEqual(active_unit_system.name, "Field") with self.assertRaises(ValueError): kw = parser["NOT_A_VALID_KEYWORD"] field = parser["FIELD"] assert (field.name == "FIELD") dkw_field = DeckKeyword(field) assert (dkw_field.name == "FIELD") DeckKeyword(parser["AQUCWFAC"], [[]], active_unit_system, default_unit_system) with self.assertRaises(TypeError): dkw_wrong = DeckKeyword(parser["AQUCWFAC"], [22.2, 0.25], active_unit_system, default_unit_system) dkw_aqannc = DeckKeyword(parser["AQANNC"], [[12, 1, 2, 3, 0.89], [13, 4, 5, 6, 0.625]], active_unit_system, default_unit_system) assert (len(dkw_aqannc[0]) == 5) assert (dkw_aqannc[0][2].get_int(0) == 2) assert (dkw_aqannc[1][1].get_int(0) == 4) with self.assertRaises(ValueError): value = dkw_aqannc[1][1].get_raw(0) with self.assertRaises(ValueError): value = dkw_aqannc[1][1].get_SI(0) assert (dkw_aqannc[1][4].get_raw(0) == 0.625) self.assertAlmostEqual(dkw_aqannc[1][4].get_SI(0), 0.625 * unit_foot**2) assert (dkw_aqannc[1][4].get_raw_data_list() == [0.625]) self.assertAlmostEqual(dkw_aqannc[1][4].get_SI_data_list()[0], 0.625 * unit_foot**2) with self.assertRaises(ValueError): value = dkw_aqannc[1][4].get_int(0) dkw_aqantrc = DeckKeyword(parser["AQANTRC"], [[12, "ABC", 8]], active_unit_system, default_unit_system) assert (dkw_aqantrc[0][1].get_str(0) == "ABC") assert (dkw_aqantrc[0][2].get_raw(0) == 8.0) dkw1 = DeckKeyword(parser["AQUCWFAC"], [["*", 0.25]], active_unit_system, default_unit_system) assert (dkw1[0][0].get_raw(0) == 0.0) assert (dkw1[0][1].get_raw(0) == 0.25) dkw2 = DeckKeyword(parser["AQUCWFAC"], [[0.25, "*"]], active_unit_system, default_unit_system) assert (dkw2[0][0].get_raw(0) == 0.25) assert (dkw2[0][1].get_raw(0) == 1.0) dkw3 = DeckKeyword(parser["AQUCWFAC"], [[0.50]], active_unit_system, default_unit_system) assert (dkw3[0][0].get_raw(0) == 0.50) assert (dkw3[0][1].get_raw(0) == 1.0) dkw4 = DeckKeyword(parser["CBMOPTS"], [["3*", "A", "B", "C", "2*", 0.375]], active_unit_system, default_unit_system) assert (dkw4[0][0].get_str(0) == "TIMEDEP") assert (dkw4[0][2].get_str(0) == "NOKRMIX") assert (dkw4[0][3].get_str(0) == "A") assert (dkw4[0][6].get_str(0) == "PMPVK") assert (dkw4[0][8].get_raw(0) == 0.375) with self.assertRaises(TypeError): dkw4[0][8].get_data_list() with self.assertRaises(TypeError): DeckKeyword(parser["CBMOPTS"], [["3*", "A", "B", "C", "R2*", 0.77]], active_unit_system, default_unit_system) with self.assertRaises(TypeError): DeckKeyword(parser["CBMOPTS"], [["3*", "A", "B", "C", "2.2*", 0.77]], active_unit_system, default_unit_system) dkw5 = DeckKeyword(parser["AQUCWFAC"], [["2*5.5"]], active_unit_system, default_unit_system) assert (dkw5[0][0].get_raw(0) == 5.5) assert (dkw5[0][1].get_raw(0) == 5.5) with self.assertRaises(ValueError): raise DeckKeyword(parser["AQANTRC"], [["1*2.2", "ABC", 8]], active_unit_system, default_unit_system)