def test_str_compdat(): """Test compdat parsing directly on strings""" schstr = """ COMPDAT 'OP1' 33 110 31 31 'OPEN' 1* 6467.31299 0.216 506642.25 0 1* 'Y' 7.18 / -- comments. / """ deck = EclFiles.str2deck(schstr) compdfs = compdat.deck2dfs(deck) compdat_df = compdfs["COMPDAT"] assert compdat_df.loc[0, "SATN"] == 0 assert not compdat_df.loc[0, "DFACT"] assert compdat_df.loc[0, "DIR"] == "Y" schstr = """ COMPDAT 'FOO' 303 1010 031 39 / / """ compdat_df = compdat.deck2dfs(EclFiles.str2deck(schstr))["COMPDAT"] assert len(compdat_df) == 9 assert not compdat_df["DFACT"].values[0] assert not compdat_df["TRAN"].values[0] assert compdat_df["I"].values[0] == 303
def inject_xxxdims_ntxxx( xxxdims: str, ntxxx_name: str, deck: Union[str, "opm.libopmcommon_python.Deck"], ntxxx_value: Optional[int] = None, ) -> "opm.libopmcommon_python.Deck": """Ensures TABDIMS/EQLDIMS is present in a deck. If ntxxx_value=None and ntxxx_name not in the deck, ntxxx_name will be inferred through trial-and-error parsing of the deck, and then injected into the deck. Args: xxxdims: TABDIMS or EQLDIMS ntxxx_name: NTPVT, NTEQUL or NTSFUN deck: A data deck. If ntxxx_name is to be estimated this *must* be a string and not a fully parsed deck. npxxx_value: Supply this if ntxxx_name is known, but not present in the deck, this will override any guessing. If the deck already contains XXXDIMS, this will be ignored. Returns: opm.io Deck object """ assert xxxdims in ["TABDIMS", "EQLDIMS"] assert ntxxx_name in ["NTPVT", "NTEQUL", "NTSFUN"] if xxxdims in deck and ntxxx_value is None: # Then we have nothing to do, but ensure we parse a potential string to a deck if isinstance(deck, str): deck = EclFiles.str2deck(deck) return deck if xxxdims in deck and ntxxx_value is not None: logger.warning("Ignoring %s argument, it is already in the deck", str(ntxxx_name)) return deck if not isinstance(deck, str): # The deck must be converted to a string deck in order # to estimate dimensions. deck = str(deck) # Estimate if ntxxx_value is not provided: if ntxxx_value is None: ntxxx_estimate = guess_dim(deck, xxxdims, DIMS_POS[ntxxx_name]) logger.warning("Estimated %s=%s", ntxxx_name, str(ntxxx_estimate)) else: ntxxx_estimate = ntxxx_value augmented_strdeck = inject_dimcount(str(deck), xxxdims, DIMS_POS[ntxxx_name], ntxxx_estimate, nowarn=True) # Overwrite the deck object deck = EclFiles.str2deck(augmented_strdeck) return deck
def test_applywelopen(): schstr = """ DATES 1 MAY 2001 / / COMPDAT 'OP1' 33 110 31 31 'OPEN' / / WELOPEN 'OP1' 'SHUT' / / TSTEP 1 / COMPDAT 'OP2' 66 110 31 31 'OPEN' / / WELOPEN 'OP1' 'OPEN' / / TSTEP 2 3 / WELOPEN 'OP1' 'POPN' / 'OP2' 'SHUT' / / """ df = compdat.deck2dfs(EclFiles.str2deck(schstr))["COMPDAT"] assert df.shape[0] == 5 assert df["OP/SH"].nunique() == 2 assert df["DATE"].nunique() == 3 schstr = """ DATES 1 MAY 2001 / / COMPDAT 'OP1' 33 110 31 31 'OPEN' / / WELOPEN 'OP2' 'SHUT' / /""" with pytest.raises(ValueError): compdat.deck2dfs(EclFiles.str2deck(schstr))["COMPDAT"]
def test_unrollwelsegs(): """Test unrolling of welsegs.""" schstr = """ WELSEGS -- seg_start to seg_end (two first items in second record) is a range of -- 2 segments, should be automatically unrolled to 2 rows. 'OP1' 1689 1923 1.0E-5 'ABS' 'HFA' 'HO' / comment without -- identifier 2 3 1 1 1923.9 1689.000 0.1172 0.000015 / / """ df = compdat.deck2dfs(EclFiles.str2deck(schstr))["WELSEGS"] assert len(df) == 2 df = compdat.deck2dfs(EclFiles.str2deck(schstr), unroll=False)["WELSEGS"] assert len(df) == 1
def test_wsegvalv(): """Test the WSEGVALV parser for column names and default values""" schstr = """ WSEGVALV -- WELL SEG CV AC Lex Dp ROUGH Ap STATUS A_MAX WELL_A 31 0.0084252 0.00075 0.5 0.216 0.0005 0.0366 SHUT 0.0008 / / """ deck = EclFiles.str2deck(schstr) wsegvalv = compdat.deck2dfs(deck)["WSEGVALV"] pd.testing.assert_frame_equal( wsegvalv, pd.DataFrame( data=[ { "WELL": "WELL_A", "SEGMENT_NUMBER": 31, "CV": 0.0084252, "AREA": 0.00075, "EXTRA_LENGTH": 0.5, "PIPE_D": 0.216, "ROUGHNESS": 0.0005, "PIPE_A": 0.0366, "STATUS": "SHUT", "MAX_A": 0.0008, "DATE": None, } ] ), )
def test_wsegvalv_max_default(): """Test the WSEGVALV parser for column names and default values. NB: Default values are taken from other keywords in Eclipse except STATUS, which is OPEN by default. Combination of keywords is not tested here.""" schstr = """ WSEGVALV -- WELL SEG CV AC WELL_A 31 0.0084252 0.00075 6* / / """ deck = EclFiles.str2deck(schstr) wsegvalv = compdat.deck2dfs(deck)["WSEGVALV"] pd.testing.assert_frame_equal( wsegvalv, pd.DataFrame( data=[ { "WELL": "WELL_A", "SEGMENT_NUMBER": 31, "CV": 0.0084252, "AREA": 0.00075, "EXTRA_LENGTH": None, "PIPE_D": None, "ROUGHNESS": None, "PIPE_A": None, "STATUS": "OPEN", "MAX_A": None, "DATE": None, } ] ), )
def test_tstep(): """Test with TSTEP present""" schstr = """ DATES 1 MAY 2001 / / COMPDAT 'OP1' 33 110 31 31 'OPEN' / / TSTEP 1 / COMPDAT 'OP1' 34 111 32 32 'OPEN' / / TSTEP 2 3 / COMPDAT 'OP1' 35 111 33 33 'SHUT' / / """ deck = EclFiles.str2deck(schstr) compdf = compdat.deck2dfs(deck)["COMPDAT"] dates = [str(x) for x in compdf["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_wsegsicd(): """Test the WSEGSICD parser for column names and default values Proves bug 232 is fixed. """ schstr = """WSEGSICD 'WELL_A' 31 31 0.00178 0.57975861 1* 1* 0.7 1* 1* 1 1* OPEN / / """ deck = EclFiles.str2deck(schstr) wsegsicd = compdat.deck2dfs(deck)["WSEGSICD"] pd.testing.assert_frame_equal( wsegsicd, pd.DataFrame(data=[{ "WELL": "WELL_A", "SEGMENT1": 31, "SEGMENT2": 31, "STRENGTH": 0.00178, "LENGTH": 0.57975861, "DENSITY_CALI": 1000.25, "VISCOSITY_CALI": 1.45, "CRITICAL_VALUE": 0.7, "WIDTH_TRANS": 0.05, "MAX_VISC_RATIO": 5, "METHOD_SCALING_FACTOR": 1, "MAX_ABS_RATE": None, "STATUS": "OPEN", "DATE": None, }]), )
def test_welopen(test_input, expected): """Test with WELOPEN present""" deck = EclFiles.str2deck(test_input) compdf = compdat.deck2dfs(deck)["COMPDAT"] columns_to_check = ["WELL", "I", "J", "K1", "K2", "OP/SH", "DATE"] assert (compdf[columns_to_check] == expected[columns_to_check]).all(axis=None)
def test_unrollcompdatk1k2(): """Test unrolling of k1-k2 ranges in COMPDAT""" schstr = """ COMPDAT -- K1 to K2 is a range of 11 layers, should be automatically -- unrolled to 11 rows. 'OP1' 33 44 10 20 / / """ df = compdat.deck2dfs(EclFiles.str2deck(schstr))["COMPDAT"] assert df["I"].unique() == 33 assert df["J"].unique() == 44 assert (df["K1"].values == range(10, 20 + 1)).all() assert (df["K2"].values == range(10, 20 + 1)).all() # Check that we can read withoug unrolling: df_noroll = compdat.deck2dfs(EclFiles.str2deck(schstr), unroll=False)["COMPDAT"] assert len(df_noroll) == 1
def test_samecellperf(): """Test that we allow multiple perforations in the same cell""" schstr = """ COMPDAT 'OP1' 1 1 1 1 / 'OP2' 1 1 1 1 / / """ df = compdat.deck2dfs(EclFiles.str2deck(schstr))["COMPDAT"] assert len(df) == 2
def test_welopen_df(): """Test that we can obtain WELOPEN information when it applies on well state, not on connections.""" deck = EclFiles.str2deck( """ DATES 1 JAN 2000 / / COMPDAT 'OP1' 1 1 1 1 'OPEN' / / WELOPEN 'OP1' 'SHUT' / -- This is ignored for connections / """ ) print(compdat.deck2dfs(deck)["WELOPEN"]) pd.testing.assert_frame_equal( compdat.deck2dfs(deck)["WELOPEN"], pd.DataFrame( columns=[ "DATE", "WELL", "I", "J", "K", "C1", "C2", "STATUS", "KEYWORD_IDX", ], data=[ [ datetime.date(2000, 1, 1), "OP1", None, None, None, None, None, "SHUT", 2, ], ], ), check_like=True, )
def test_wsegaicd(): """Test the WSEGAICD parser for column names and default values""" schstr = """WSEGAICD OP_6 31 31 1.7e-05 -1.18 1000 1.0 0.5 4* 3.05 0.67 OPEN 1.0 1.0 1.0 2.43 1.18 10.0 / / """ deck = EclFiles.str2deck(schstr) wsegaicd = compdat.deck2dfs(deck)["WSEGAICD"] pd.testing.assert_frame_equal( wsegaicd, pd.DataFrame( data=[ { "WELL": "OP_6", "SEGMENT1": 31, "SEGMENT2": 31, "STRENGTH": 1.7e-05, "LENGTH": -1.18, "DENSITY_CALI": 1000.0, "VISCOSITY_CALI": 1.0, "CRITICAL_VALUE": 0.5, "WIDTH_TRANS": 0.05, "MAX_VISC_RATIO": 5, "METHOD_SCALING_FACTOR": -1, "MAX_ABS_RATE": None, "FLOW_RATE_EXPONENT": 3.05, "VISC_EXPONENT": 0.67, "STATUS": "OPEN", "OIL_FLOW_FRACTION": 1.0, "WATER_FLOW_FRACTION": 1.0, "GAS_FLOW_FRACTION": 1.0, "OIL_VISC_FRACTION": 2.43, "WATER_VISC_FRACTION": 1.18, "GAS_VISC_FRACTION": 10.0, "DATE": None, } ] ), )
def test_parse_wlist(deckstr, expected_df): deck = EclFiles.str2deck(deckstr) wlistdf = compdat.deck2dfs(deck)["WLIST"] pd.testing.assert_frame_equal(wlistdf, expected_df, check_like=True)
def test_str2df(): """Testing making a dataframe from an explicit string""" schstr = """ WELSPECS 'OP1' 'OPWEST' 41 125 1759.74 'OIL' 0.0 'STD' 'SHUT' 'YES' 0 'SEG' / / COMPDAT 'OP1' 33 110 31 31 'OPEN' 0 6467.31299 0.216 506642.25 0.0 0.0 'Y' 7.18 / -- comments. / WELSEGS 'OP1' 1689 1923 1.0E-5 'ABS' 'HFA' 'HO' / comment without -- identifier -- foo bar 2 2 1 1 1923.9 1689.000 0.1172 0.000015 / / COMPSEGS 'OP1' / -- Yet a comment -- comment 41 125 29 5 2577.0 2616.298 / icd on branch 1 in segment 17 / -- (WSEGVALS is not processed) WSEGVALV 'OP1' 166 1 7.4294683E-06 0 / icd on segment 17, cell 41 125 29 / """ deck = EclFiles.str2deck(schstr) compdfs = compdat.deck2dfs(deck) compdat_df = compdfs["COMPDAT"] welsegs = compdfs["WELSEGS"] compsegs = compdfs["COMPSEGS"] assert "WELL" in compdat_df assert len(compdat_df) == 1 assert compdat_df["WELL"].unique()[0] == "OP1" # Check that we have not used the very long opm.io term here: assert "CONNECTION_TRANSMISSIBILITY_FACTOR" not in compdat_df assert "TRAN" in compdat_df assert "Kh" not in compdat_df # Mixed-case should not be used. assert "KH" in compdat_df # Make sure the ' are ignored: assert compdat_df["OP/SH"].unique()[0] == "OPEN" # Continue to WELSEGS assert len(welsegs) == 1 # First record is appended to every row. # Since we have 'ABS' in WELSEGS, there should be an extra # column called 'SEGMENT_MD' assert "SEGMENT_MD" in welsegs assert welsegs["SEGMENT_MD"].max() == 1923.9 # Test COMPSEGS assert len(compsegs) == 1 assert "WELL" in compsegs assert compsegs["WELL"].unique()[0] == "OP1" assert len(compsegs.dropna(axis=1, how="all").iloc[0]) == 8 # Check date handling assert "DATE" in compdat_df assert not all(compdat_df["DATE"].notna()) compdat_date = compdat.deck2dfs(deck, start_date="2000-01-01")["COMPDAT"] assert "DATE" in compdat_date assert all(compdat_date["DATE"].notna()) assert len(compdat_date["DATE"].unique()) == 1 assert str(compdat_date["DATE"].unique()[0]) == "2000-01-01"
def test_msw_str2df(): """Testing making a dataframe from an explicit string including MSW""" schstr = """ WELSPECS 'OP_6' 'DUMMY' 28 37 1575.82 OIL 0.0 'STD' 'SHUT' 'YES' 0 'SEG' / / COMPDAT 'OP_6' 28 37 1 1 OPEN 0 1.27194551 0.311 114.88788 0.0 0.0 'X' 19.652259 / / WELSEGS -- WELL SEGMENTTVD SEGMENTMD WBVOLUME INFOTYPE PDROPCOMP MPMODEL 'OP_6' 0.0 0.0 1.0E-5 'ABS' 'HF-' 'HO' / -- SEG SEG2 BRANCH OUT MD TVD DIAM ROUGHNESS 2 2 1 1 2371.596 1577.726 0.15 0.00065 / / COMPSEGS 'OP_6' / -- I J K BRANCH STARTMD ENDMD DIR DEF SEG 28 37 1 2 2366.541 2376.651 1* 3* 31 / / WSEGAICD -- WELL SEG SEG2 ALPHA SF RHO VIS EMU DEF X Y FLAG A B C D E F OP_6 31 31 1.7253e-05 -1.186915444 1000.0 1.0 0.5 4* 3.05 0.67 OPEN 1.0 1.0 1.0 2.43 1.18 10.0 / / """ deck = EclFiles.str2deck(schstr) compdfs = compdat.deck2dfs(deck) compdat_df = compdfs["COMPDAT"] welsegs = compdfs["WELSEGS"] compsegs = compdfs["COMPSEGS"] wsegaicd = compdfs["WSEGAICD"] assert "WELL" in compdat_df assert len(compdat_df) == 1 assert compdat_df["WELL"].unique()[0] == "OP_6" # Check that we have not used the very long opm.io term here: assert "CONNECTION_TRANSMISSIBILITY_FACTOR" not in compdat_df assert "TRAN" in compdat_df assert "Kh" not in compdat_df # Mixed-case should not be used. assert "KH" in compdat_df # Make sure the ' are ignored: assert compdat_df["OP/SH"].unique()[0] == "OPEN" # Continue to WELSEGS assert len(welsegs) == 1 # First record is appended to every row. # Since we have 'ABS' in WELSEGS, there should be an extra # column called 'SEGMENT_MD' assert "SEGMENT_MD" in welsegs assert welsegs["SEGMENT_MD"].max() == 2371.596 # Test COMPSEGS assert len(compsegs) == 1 assert "WELL" in compsegs assert compsegs["WELL"].unique()[0] == "OP_6" assert len(compsegs.dropna(axis=1, how="all").iloc[0]) == 9 # Test WSEGAICD assert len(wsegaicd) == 1 assert "WELL" in wsegaicd assert wsegaicd["WELL"].unique()[0] == "OP_6" assert len(wsegaicd.dropna(axis=1, how="all").iloc[0]) == 19 # Check date handling assert "DATE" in compdat_df assert not all(compdat_df["DATE"].notna()) compdat_date = compdat.deck2dfs(deck, start_date="2000-01-01")["COMPDAT"] assert "DATE" in compdat_date assert all(compdat_date["DATE"].notna()) assert len(compdat_date["DATE"].unique()) == 1 assert str(compdat_date["DATE"].unique()[0]) == "2000-01-01"
def test_defaulted_compdat_i_j(tmp_path): """I and J can be defaulted (that is 1* or 0) in COMPDAT records, then that information should be fetched from the most recent WELSPECS keyword """ welspecs_str = """ WELSPECS OP1 OPWEST 20 30 1000 / / """ compdat_str_def_i = """ COMPDAT 'OP1' 1* 0 10 11 / / """ compdat_str_def_j = """ COMPDAT 'OP1' 20 1* 10 11 / / """ compdat_str_nodefaults = """ COMPDAT 'OP1' 55 66 80 80 / / """ with pytest.raises(ValueError, match="WELSPECS must be provided when I"): compdat.deck2dfs(EclFiles.str2deck(compdat_str_def_i))["COMPDAT"] # I value of 0 also means defaulted: with pytest.raises(ValueError, match="WELSPECS must be provided when I"): compdat.deck2dfs(EclFiles.str2deck(compdat_str_def_i.replace("1*", "0")))[ "COMPDAT" ] with pytest.raises(ValueError, match="WELSPECS must be provided when J"): compdat.deck2dfs(EclFiles.str2deck(compdat_str_def_j))["COMPDAT"] # J value of 0 also means defaulted: with pytest.raises(ValueError, match="WELSPECS must be provided when J"): compdat.deck2dfs(EclFiles.str2deck(compdat_str_def_j.replace("1*", "0")))[ "COMPDAT" ] with pytest.raises(ValueError, match="WELSPECS must be provided"): # Wrong order: compdat.deck2dfs(EclFiles.str2deck(compdat_str_def_i + welspecs_str))["COMPDAT"] # Simplest example: compdat_df = compdat.deck2dfs(EclFiles.str2deck(welspecs_str + compdat_str_def_i))[ "COMPDAT" ] assert compdat_df["I"].unique() == [20] assert compdat_df["J"].unique() == [30] # Two wells: compdat_df = compdat.deck2dfs( EclFiles.str2deck( welspecs_str.replace("OP1", "OP2").replace("30", "99") + welspecs_str + compdat_str_def_i ) )["COMPDAT"] # Partial defaulting compdat_df = compdat.deck2dfs( EclFiles.str2deck(welspecs_str + compdat_str_def_i + compdat_str_nodefaults) )["COMPDAT"] assert set(compdat_df["I"].unique()) == {20, 55} assert set(compdat_df["J"].unique()) == {30, 66} compdat_df = compdat.deck2dfs( EclFiles.str2deck( welspecs_str.replace("OP1", "OP2").replace("30", "99") + welspecs_str + compdat_str_def_i + compdat_str_def_i.replace("OP1", "OP2") ) )["COMPDAT"] assert compdat_df[compdat_df["WELL"] == "OP1"]["I"].unique() == [20] assert compdat_df[compdat_df["WELL"] == "OP2"]["I"].unique() == [20] assert compdat_df[compdat_df["WELL"] == "OP1"]["J"].unique() == [30] assert compdat_df[compdat_df["WELL"] == "OP2"]["J"].unique() == [99] # Same well redrilled to new location compdat_df = compdat.deck2dfs( EclFiles.str2deck( "DATES\n 1 JAN 2030 /\n/\n" + welspecs_str + compdat_str_def_i + "DATES\n 1 JAN 2040 /\n/\n" + welspecs_str.replace("30", "33") + compdat_str_def_i ) )["COMPDAT"] assert compdat_df[compdat_df["DATE"].astype(str) == "2030-01-01"]["J"].unique() == [ 30 ] assert compdat_df[compdat_df["DATE"].astype(str) == "2040-01-01"]["J"].unique() == [ 33 ]
def test_welopen_wlist(test_input, expected): deck = EclFiles.str2deck(test_input) dfs = compdat.deck2dfs(deck) pd.testing.assert_frame_equal(dfs["COMPDAT"][expected.columns], expected)
def test_msw_str2df(): """Testing making a dataframe from an explicit string including MSW""" schstr = """ WELSPECS 'OP_6' 'DUMMY' 28 37 1575.82 OIL 0.0 'STD' 'SHUT' 'YES' 0 'SEG' / / COMPDAT 'OP_6' 28 37 1 1 OPEN 0 1.2719 0.311 114.887 0.0 0.0 'X' 19.65 / / WELSEGS -- WELL SEGMENTTVD SEGMENTMD WBVOLUME INFOTYPE PDROPCOMP MPMODEL 'OP_6' 0.0 0.0 1.0E-5 'ABS' 'HF-' 'HO' / -- SEG SEG2 BRANCH OUT MD TVD DIAM ROUGHNESS 2 2 1 1 2371.596 1577.726 0.15 0.00065 / / COMPSEGS 'OP_6' / -- I J K BRANCH STARTMD ENDMD DIR DEF SEG 28 37 1 2 2366.541 2376.651 1* 3* 31 / / WSEGAICD -- WELL SEG SEG2 ALPHA SF RHO VIS EMU DEF X Y -- FLAG A B C D E F OP_6 31 31 1.7e-05 -1.18 1000 1.0 0.5 4* 3.05 0.67 OPEN 1.0 1.0 1.0 2.43 1.18 10.0 / / WSEGSICD -- WELL SEG SEG2 ALPHA SF RHO VIS WCT OP_6 31 31 0.0001 -1.186915444 1000.0 1.0 0.5 / / WSEGVALV -- WELL SEG CV AC L OP_6 31 0.0084252 0.00075 1* / / """ deck = EclFiles.str2deck(schstr) compdfs = compdat.deck2dfs(deck) wsegaicd = compdfs["WSEGAICD"] wsegsicd = compdfs["WSEGSICD"] wsegvalv = compdfs["WSEGVALV"] # Test WSEGAICD assert len(wsegaicd) == 1 assert "WELL" in wsegaicd assert wsegaicd["WELL"].unique()[0] == "OP_6" assert len(wsegaicd.dropna(axis=1, how="all").iloc[0]) == 20 # Test WSEGSICD assert len(wsegsicd) == 1 assert "WELL" in wsegsicd assert wsegsicd["WELL"].unique()[0] == "OP_6" assert len(wsegsicd.dropna(axis=1, how="all").iloc[0]) == 12 # Test WSEGVALV assert len(wsegvalv) == 1 assert "WELL" in wsegvalv assert wsegvalv["WELL"].unique()[0] == "OP_6" assert len(wsegvalv.dropna(axis=1, how="all").iloc[0]) == 5
def guess_dim(deckstring, dimkeyword, dimitem=0): """Guess the correct dimension count for an incoming deck (string) The incoming deck must in string form, if not, extra data is most likely already removed by the opm.io parser. TABDIMS or EQLDIMS must not be present This function will inject TABDIMS or EQLDIMS into it and reparse it in a stricter mode, to detect the correct table dimensionality Arguments: deck (str): String containing an Eclipse deck or only a few Eclipse keywords dimkeyword (str): Either TABDIMS or EQLDIMS dimitem (int): The element number in TABDIMS/EQLDIMS to modify Returns: int: The lowest number for which stricter opm.io parsing succeeds """ if dimkeyword not in ["TABDIMS", "EQLDIMS"]: raise ValueError("Only supports TABDIMS and EQLDIMS") if dimkeyword == "TABDIMS": if dimitem not in [0, 1]: raise ValueError("Only support item 0 and 1 in TABDIMS") if dimkeyword == "EQLDIMS": if dimitem not in [0]: raise ValueError("Only item 0 in EQLDIMS can be estimated") # A less than ecl2df-standard permissive opm.io, when using # this one opm.io will fail if there are extra records # in tables (if NTSFUN in TABDIMS is wrong f.ex): opmioparser_recovery_fail_extra_records = [ ("PARSE_UNKNOWN_KEYWORD", opm.io.action.ignore), ("SUMMARY_UNKNOWN_GROUP", opm.io.action.ignore), ("UNSUPPORTED_*", opm.io.action.ignore), ("PARSE_MISSING_SECTIONS", opm.io.action.ignore), ("PARSE_RANDOM_TEXT", opm.io.action.ignore), ("PARSE_MISSING_INCLUDE", opm.io.action.ignore), ] max_guess = 640 # This ought to be enough for everybody dimcountguess = 0 for dimcountguess in range(1, max_guess + 1): deck_candidate = inject_dimcount(deckstring, dimkeyword, dimitem, dimcountguess, nowarn=True) try: EclFiles.str2deck( deck_candidate, parsecontext=opm.io.ParseContext( opmioparser_recovery_fail_extra_records), ) # If we succeed, then the dimcountguess was correct break except ValueError: # Typically we get the error PARSE_EXTRA_RECORDS because we did not guess # high enough dimnumcount continue # If we get here, try another dimnumcount if dimcountguess == max_guess: logger.warning("Unable to guess dim count for %s, or larger than %d", dimkeyword, max_guess) logger.info("Guessed dimension count count for %s to %d", dimkeyword, dimcountguess) return dimcountguess
def test_welopen_complump(test_input, expected): """Test the welopen_complump functionality through Eclipse decks""" deck = EclFiles.str2deck(test_input) dfs = compdat.deck2dfs(deck) pd.testing.assert_frame_equal(dfs["COMPDAT"][expected.columns], expected)