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_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 from_ecl_init_file(ecl_init_file: EclFile) -> Optional["Water"]: intehead = ecl_init_file.__getitem__(InitFileDefinitions.INTEHEAD_KW) intehead_phase = intehead[InitFileDefinitions.INTEHEAD_PHASE_INDEX] if (intehead_phase & (1 << 2)) == 0: return None raw = EclPropertyTableRawData() tab_dims = ecl_init_file.__getitem__("TABDIMS") tab = ecl_init_file.__getitem__("TAB") raw.num_primary = 1 raw.num_rows = 1 raw.num_cols = 5 raw.num_tables = tab_dims[InitFileDefinitions.TABDIMS_NTPVTG_ITEM] if raw.num_tables == 0: return None num_tab_elements = ( raw.num_primary * raw.num_rows * raw.num_cols * raw.num_tables ) start = tab_dims[InitFileDefinitions.TABDIMS_IBPVTW_OFFSET_ITEM] - 1 raw.data = tab[start : start + num_tab_elements] rhos = surface_mass_density(ecl_init_file, EclPhaseIndex.Aqua) return Water(raw, rhos)
def from_ecl_init_file(ecl_init_file: EclFile, keep_unit_system: bool = False) -> Optional["Oil"]: """Reads the given Eclipse file and creates an Oil object from its data. Args: ecl_init_file: Eclipse INIT file keep_unit_system: Set to True if the unit system used in the Eclipse file shall be kept, False if SI shall be used. Returns: An Oil object or None if the data in the Eclipse file was invalid """ intehead = ecl_init_file.__getitem__(InitFileDefinitions.INTEHEAD_KW) logihead = ecl_init_file.__getitem__(InitFileDefinitions.LOGIHEAD_KW) is_is_const_compr = bool(logihead[is_const_compr_index()]) raw = EclPropertyTableRawData() tab_dims = ecl_init_file.__getitem__("TABDIMS") tab = ecl_init_file.__getitem__("TAB") num_rs = tab_dims[InitFileDefinitions.TABDIMS_NRPVTO_ITEM] raw.num_rows = tab_dims[InitFileDefinitions.TABDIMS_NPPVTO_ITEM] raw.num_cols = 5 raw.num_tables = tab_dims[InitFileDefinitions.TABDIMS_NTPVTO_ITEM] if raw.num_tables == 0: return None if logihead[InitFileDefinitions.LOGIHEAD_RS_INDEX]: raw.num_primary = num_rs else: raw.num_primary = 1 num_tab_elements = raw.num_primary * raw.num_tables start = tab_dims[InitFileDefinitions.TABDIMS_JBPVTO_OFFSET_ITEM] - 1 raw.primary_key = tab[start:start + num_tab_elements] num_tab_elements = (raw.num_primary * raw.num_rows * raw.num_cols * raw.num_tables) start = tab_dims[InitFileDefinitions.TABDIMS_IBPVTO_OFFSET_ITEM] - 1 raw.data = tab[start:start + num_tab_elements] surface_mass_densities = surface_mass_density(ecl_init_file, EclPhaseIndex.Liquid, keep_unit_system) return Oil( raw, intehead[InitFileDefinitions.INTEHEAD_UNIT_INDEX], is_is_const_compr, surface_mass_densities, keep_unit_system, )
def from_ecl_init_file( ecl_init_file: EclFile, keep_unit_system: bool = False ) -> Optional["Water"]: """Reads the given Eclipse file and creates a Water object from its data. Args: ecl_init_file: Eclipse INIT file keep_unit_system: Set to True if the unit system used in the Eclipse file shall be kept, False if SI shall be used. Returns: A Water object or None if the data in the Eclipse file was invalid """ intehead = ecl_init_file.__getitem__(InitFileDefinitions.INTEHEAD_KW) intehead_phase = intehead[InitFileDefinitions.INTEHEAD_PHASE_INDEX] if (intehead_phase & (1 << 2)) == 0: return None raw = EclPropertyTableRawData() tab_dims = ecl_init_file.__getitem__("TABDIMS") tab = ecl_init_file.__getitem__("TAB") raw.num_primary = 1 # Single record per region raw.num_rows = 1 # Single record per region raw.num_cols = 5 # [ Pw, 1/B, Cw, 1/(B*mu), Cw - Cv ] raw.num_tables = tab_dims[InitFileDefinitions.TABDIMS_NTPVTW_ITEM] if raw.num_tables == 0: return None num_tab_elements = ( raw.num_primary * raw.num_rows * raw.num_cols * raw.num_tables ) start = tab_dims[InitFileDefinitions.TABDIMS_IBPVTW_OFFSET_ITEM] - 1 raw.data = tab[start : start + num_tab_elements] surface_mass_densities = surface_mass_density( ecl_init_file, EclPhaseIndex.AQUA, keep_unit_system ) return Water( raw, intehead[InitFileDefinitions.INTEHEAD_UNIT_INDEX], surface_mass_densities, keep_unit_system, )
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 init_to_pvt_data_frame(kwargs) -> pd.DataFrame: # pylint: disable-msg=too-many-locals ecl_init_file = EclFile( kwargs["realization"].get_eclfiles().get_initfile().get_filename()) oil = Oil.from_ecl_init_file(ecl_init_file) gas = Gas.from_ecl_init_file(ecl_init_file) water = Water.from_ecl_init_file(ecl_init_file) column_pvtnum = [] column_oil_gas_ratio = [] column_volume_factor = [] column_pressure = [] column_viscosity = [] column_keyword = [] for table_index, table in enumerate(oil.tables()): for outer_pair in table.get_values(): for inner_pair in outer_pair.y: column_pvtnum.append(table_index + 1) column_keyword.append("PVTO") column_oil_gas_ratio.append(outer_pair.x) column_pressure.append(inner_pair.x) column_volume_factor.append(1 / inner_pair.y[0]) column_viscosity.append(inner_pair.y[0] / inner_pair.y[1]) for table_index, table in enumerate(gas.tables()): for outer_pair in table.get_values(): for inner_pair in outer_pair.y: column_pvtnum.append(table_index + 1) column_keyword.append("PVDG") if isinstance(table, DryGas): column_oil_gas_ratio.append(0) else: column_oil_gas_ratio.append(outer_pair.x) column_pressure.append(inner_pair.x) column_volume_factor.append(1 / inner_pair.y[0]) column_viscosity.append(inner_pair.y[0] / inner_pair.y[1]) for table_index, table in enumerate(water.tables()): for outer_pair in table.get_values(): for inner_pair in outer_pair.y: column_pvtnum.append(table_index + 1) column_keyword.append("PVTW") column_oil_gas_ratio.append(outer_pair.x) column_pressure.append(inner_pair.x) column_volume_factor.append(1 / inner_pair.y[0]) column_viscosity.append(1.0 / inner_pair.y[2] * inner_pair.y[0]) data_frame = pd.DataFrame({ "PVTNUM": column_pvtnum, "KEYWORD": column_keyword, "RS": column_oil_gas_ratio, "PRESSURE": column_pressure, "VOLUMEFACTOR": column_volume_factor, "VISCOSITY": column_viscosity, }) return data_frame
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 from_ecl_init_file(ecl_init_file: EclFile) -> Optional["Gas"]: intehead = ecl_init_file.__getitem__(InitFileDefinitions.INTEHEAD_KW) intehead_phase = intehead[InitFileDefinitions.INTEHEAD_PHASE_INDEX] if (intehead_phase & (1 << 2)) == 0: return None raw = EclPropertyTableRawData() tab_dims = ecl_init_file.__getitem__("TABDIMS") tab = ecl_init_file.__getitem__("TAB") num_rv = tab_dims[InitFileDefinitions.TABDIMS_NRPVTG_ITEM] num_pg = tab_dims[InitFileDefinitions.TABDIMS_NPPVTG_ITEM] raw.num_cols = 5 raw.num_tables = tab_dims[InitFileDefinitions.TABDIMS_NTPVTG_ITEM] if raw.num_tables == 0: return None logihead = ecl_init_file.__getitem__(InitFileDefinitions.LOGIHEAD_KW) if logihead[InitFileDefinitions.LOGIHEAD_RV_INDEX]: raw.num_primary = num_pg raw.num_rows = num_rv else: raw.num_primary = 1 raw.num_rows = num_pg num_tab_elements = raw.num_primary * raw.num_tables start = tab_dims[InitFileDefinitions.TABDIMS_JBPVTG_OFFSET_ITEM] - 1 raw.primary_key = tab[start : start + num_tab_elements] num_tab_elements = ( raw.num_primary * raw.num_rows * raw.num_cols * raw.num_tables ) start = tab_dims[InitFileDefinitions.TABDIMS_IBPVTG_OFFSET_ITEM] - 1 raw.data = tab[start : start + num_tab_elements] rhos = surface_mass_density(ecl_init_file, EclPhaseIndex.Vapour) return Gas(raw, rhos)
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_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 surface_mass_density(ecl_file: EclFile, phase: EclPhaseIndex, keep_unit_system: bool = True) -> np.ndarray: """Extracts the surface mass density from the given Eclipse file for the given phase. Args: ecl_file: The Eclipse file to extract data from phase: Fluid phase to extract data for Returns: Surface mass density values. """ if phase is EclPhaseIndex.LIQUID: col = 0 elif phase is EclPhaseIndex.AQUA: col = 1 elif phase is EclPhaseIndex.VAPOUR: col = 2 else: raise AttributeError("Phase must be Liquid, Water or Vapour.") tabdims = ecl_file.__getitem__("TABDIMS") tab = ecl_file.__getitem__("TAB") start = tabdims[InitFileDefinitions.TABDIMS_IBDENS_OFFSET_ITEM] - 1 nreg = tabdims[InitFileDefinitions.TABDIMS_NTDENS_ITEM] rho = tab[start + nreg * (col + 0):start + nreg * (col + 1)] intehead = ecl_file.__getitem__(InitFileDefinitions.INTEHEAD_KW) unit_system = EclUnits.create_unit_system( intehead[InitFileDefinitions.INTEHEAD_UNIT_INDEX]) if not keep_unit_system: rho = [ Unit.Convert.from_(rho_i, unit_system.density().value) for rho_i in rho ] return rho
def test_get_function_logi(self): file1 = EclFile(test_path("data/9_EDITNNC.INIT")) self.assertTrue("LOGIHEAD" in file1) logih_index = array_index(file1, "LOGIHEAD")[0] logih = file1[logih_index] self.assertEqual(len(logih), 121) self.assertEqual(logih[0], True) self.assertEqual(logih[2], False) self.assertEqual(logih[8], False)
def surface_mass_density(ecl_file: EclFile, phase: EclPhaseIndex) -> List[float]: if phase is EclPhaseIndex.Liquid: col = 0 elif phase is EclPhaseIndex.Aqua: col = 1 elif phase is EclPhaseIndex.Vapour: col = 2 else: col = -1 if col == -1: raise AttributeError("Phase must be Liquid, Aqua or Vapour.") tabdims = ecl_file.__getitem__("TABDIMS") tab = ecl_file.__getitem__("TAB") start = tabdims[InitFileDefinitions.TABDIMS_IBDENS_OFFSET_ITEM] - 1 nreg = tabdims[InitFileDefinitions.TABDIMS_NTDENS_ITEM] rho = [tab[start + nreg * (col + 0)], tab[start + nreg * (col + 1)]] return rho
def test_get_function_double(self): refTabData=[0.147E+02, 0.2E+21, 0.4E+03, 0.2E+21, 0.8E+03, 0.2E+21, 0.12E+04, 0.2E+21, 0.16E+04, 0.2E+21, 0.2E+04, 0.2E+21, 0.24E+04, 0.2E+21, 0.28E+04, 0.2E+21, 0.32E+04, 0.2E+21, 0.36E+04, 0.2E+21, 0.4E+04, 0.5E+04, 0.1E+01, 0.2E+21, 0.98814229249012E+00, 0.2E+21, 0.97513408093613E+00] file1 = EclFile(test_path("data/SPE9.INIT")) tab_index = array_index(file1, "TAB")[0] tab = file1[tab_index] self.assertTrue(isinstance(tab, np.ndarray)) self.assertEqual(tab.dtype, "float64") for i in range(0, len(refTabData)): self.assertLess(abs(1.0 - refTabData[i]/tab[i]), 1e-12 )
def test_get_function_integer(self): refTabdims = [ 885, 1, 1, 1, 1, 1, 1, 67, 11, 2, 1, 78, 1, 78, 78, 0, 0, 0, 83, 1, 686, 40, 1, 86, 40, 1, 286, 1, 80, 1 ] file1 = EclFile(test_path("data/SPE9.INIT")) tabdims_index = array_index(file1, "TABDIMS")[0] tabdims = file1[tabdims_index] self.assertTrue(isinstance(tabdims, np.ndarray)) self.assertEqual(tabdims.dtype, "int32") for i in range(0, len(refTabdims)): self.assertEqual(refTabdims[i], tabdims[i])
def test_get_function(self): file1 = EclFile(test_path("data/SPE9.INIT"), preload=True) first = file1[0] self.assertEqual(len(first), 95) #fourth array in file SPE9.INIT which is PORV test1 = file1[3] porv_index = array_index(file1, "PORV")[0] test2 = file1[porv_index] for val1, val2 in zip(test1, test2): self.assertEqual(val1, val2)
def from_ecl_init_file(ecl_init_file: EclFile) -> Optional["Oil"]: logihead = ecl_init_file.__getitem__(InitFileDefinitions.LOGIHEAD_KW) is_const_compr = bool(logihead[const_compr_index()]) raw = EclPropertyTableRawData() tab_dims = ecl_init_file.__getitem__("TABDIMS") tab = ecl_init_file.__getitem__("TAB") num_rs = tab_dims[InitFileDefinitions.TABDIMS_NRPVTO_ITEM] raw.num_rows = tab_dims[InitFileDefinitions.TABDIMS_NPPVTO_ITEM] raw.num_cols = 5 raw.num_tables = tab_dims[InitFileDefinitions.TABDIMS_NTPVTO_ITEM] if raw.num_tables == 0: return None if logihead[InitFileDefinitions.LOGIHEAD_RS_INDEX]: raw.num_primary = num_rs else: raw.num_primary = 1 num_tab_elements = raw.num_primary * raw.num_tables start = tab_dims[InitFileDefinitions.TABDIMS_JBPVTO_OFFSET_ITEM] - 1 raw.primary_key = tab[start : start + num_tab_elements] num_tab_elements = ( raw.num_primary * raw.num_rows * raw.num_cols * raw.num_tables ) start = tab_dims[InitFileDefinitions.TABDIMS_IBPVTO_OFFSET_ITEM] - 1 raw.data = tab[start : start + num_tab_elements] rhos = surface_mass_density(ecl_init_file, EclPhaseIndex.Liquid) return Oil(raw, is_const_compr, rhos)
def test_write_binary_float32(self): npArr1 = np.array([1.1, 2.2e+28, 3.3, 4.4], dtype='float32') testFile = test_path("data/RESULT.INIT") # default is binary format (unformatted) and append = false out1 = EclOutput(testFile) out1.write("ARR1", npArr1) file1 = EclFile(testFile) testArray = file1[0] self.assertEqual(len(testArray), len(npArr1)) for v1, v2 in zip(testArray, npArr1): self.assertEqual(v1, v2) if os.path.isfile(testFile): os.remove(testFile)
def init_to_pvt_data_frame(kwargs: Any) -> pd.DataFrame: # pylint: disable-msg=too-many-locals # pylint: disable=too-many-nested-blocks # pylint: disable=too-many-branches ecl_init_file = EclFile( kwargs["realization"].get_eclfiles().get_initfile().get_filename()) oil = Oil.from_ecl_init_file(ecl_init_file) gas = Gas.from_ecl_init_file(ecl_init_file) water = Water.from_ecl_init_file(ecl_init_file) column_pvtnum = [] column_oil_gas_ratio = [] column_volume_factor = [] column_pressure = [] column_viscosity = [] column_keyword = [] if oil: if len(oil.tables()) > 0 and isinstance(oil.tables()[0], LiveOil): keyword = "PVTO" elif len(oil.tables()) > 0 and isinstance(oil.tables()[0], DeadOil): keyword = "PVDO" else: raise NotImplementedError( f"Oil of type '{type(oil)}' is not supported yet.") for table_index, table in enumerate(oil.tables()): for outer_pair in table.get_values(): for inner_pair in outer_pair.y: if isinstance(inner_pair, VariateAndValues): column_pvtnum.append(table_index + 1) column_keyword.append(keyword) if isinstance(table, DeadOil): column_oil_gas_ratio.append(0.0) else: column_oil_gas_ratio.append(outer_pair.x) column_pressure.append(inner_pair.x) column_volume_factor.append( 1.0 / inner_pair.get_values_as_floats()[0]) column_viscosity.append( inner_pair.get_values_as_floats()[0] / inner_pair.get_values_as_floats()[1]) if gas: if len(gas.tables()) > 0 and isinstance(gas.tables()[0], DryGas): keyword = "PVDG" elif len(gas.tables()) > 0 and isinstance(gas.tables()[0], WetGas): keyword = "PVTG" else: raise NotImplementedError( f"Gas of type '{type(gas)}' is not supported yet.") for table_index, table in enumerate(gas.tables()): for outer_pair in table.get_values(): for inner_pair in outer_pair.y: if isinstance(inner_pair, VariateAndValues): column_pvtnum.append(table_index + 1) column_keyword.append(keyword) if isinstance(table, DryGas): column_oil_gas_ratio.append(0.0) column_pressure.append(inner_pair.x) else: column_oil_gas_ratio.append(inner_pair.x) column_pressure.append(outer_pair.x) column_volume_factor.append( 1.0 / inner_pair.get_values_as_floats()[0]) column_viscosity.append( inner_pair.get_values_as_floats()[0] / inner_pair.get_values_as_floats()[1]) if water: for table_index, table in enumerate(water.tables()): for outer_pair in table.get_values(): for inner_pair in outer_pair.y: if isinstance(inner_pair, VariateAndValues): column_pvtnum.append(table_index + 1) column_keyword.append("PVTW") column_oil_gas_ratio.append(outer_pair.x) column_pressure.append(inner_pair.x) column_volume_factor.append( 1.0 / inner_pair.get_values_as_floats()[0]) column_viscosity.append( 1.0 / inner_pair.get_values_as_floats()[2] * inner_pair.get_values_as_floats()[0]) data_frame = pd.DataFrame({ "PVTNUM": column_pvtnum, "KEYWORD": column_keyword, "R": column_oil_gas_ratio, "PRESSURE": column_pressure, "VOLUMEFACTOR": column_volume_factor, "VISCOSITY": column_viscosity, }) return data_frame
def init_to_pvt_data_frame(kwargs: Any) -> pd.DataFrame: # pylint: disable-msg=too-many-locals # pylint: disable=too-many-nested-blocks # pylint: disable=too-many-branches check_if_ecl2df_is_installed() ecl_init_file = EclFile( kwargs["realization"].get_eclfiles().get_initfile().get_filename() ) # Keep the original unit system oil = Oil.from_ecl_init_file(ecl_init_file, True) gas = Gas.from_ecl_init_file(ecl_init_file, True) water = Water.from_ecl_init_file(ecl_init_file, True) column_pvtnum: List[int] = [] column_ratio: List[float] = [] column_volume_factor: List[float] = [] column_volume_factor_unit: List[str] = [] column_pressure: List[float] = [] column_pressure_unit: List[str] = [] column_viscosity: List[float] = [] column_viscosity_unit: List[str] = [] column_keyword: List[str] = [] ratios: np.ndarray = np.zeros(21) pressures: np.ndarray = np.zeros(21) (pressure_min, pressure_max) = (0.0, 0.0) if oil and not oil.is_dead_oil_const_compr(): (pressure_min, pressure_max) = oil.range_independent(0) elif gas: (pressure_min, pressure_max) = gas.range_independent(0) else: raise NotImplementedError("Missing PVT data") for pressure_step in range(0, 20 + 1): pressures[pressure_step] = pressure_min + pressure_step / 20.0 * ( pressure_max - pressure_min ) ratios[pressure_step] = 0.0 if oil: if oil.is_live_oil(): keyword = "PVTO" elif oil.is_dead_oil(): keyword = "PVDO" elif oil.is_dead_oil_const_compr(): keyword = "PVCDO" else: raise NotImplementedError( "The PVT property type of oil is not implemented." ) for region_index, region in enumerate(oil.regions()): if oil.is_dead_oil_const_compr(): column_pvtnum.extend([region_index + 1 for _ in pressures]) column_keyword.extend([keyword for _ in pressures]) column_ratio.extend(ratios) column_pressure.extend(pressures) column_pressure_unit.extend( [oil.pressure_unit() for _ in pressures] ) column_volume_factor.extend( region.formation_volume_factor(ratios, pressures) ) column_volume_factor_unit.extend( [oil.formation_volume_factor_unit() for _ in pressures] ) column_viscosity.extend(region.viscosity(ratios, pressures)) column_viscosity_unit.extend( [oil.viscosity_unit() for _ in pressures] ) else: (ratio, pressure) = ( region.get_keys(), region.get_independents(), ) column_pvtnum.extend([region_index + 1 for _ in pressure]) column_keyword.extend([keyword for _ in pressure]) column_ratio.extend(ratio) column_pressure.extend(pressure) column_pressure_unit.extend([oil.pressure_unit() for _ in pressure]) column_volume_factor.extend( region.formation_volume_factor(ratio, pressure) ) column_volume_factor_unit.extend( [oil.formation_volume_factor_unit() for _ in pressure] ) column_viscosity.extend(region.viscosity(ratio, pressure)) column_viscosity_unit.extend( [oil.viscosity_unit() for _ in pressure] ) if gas: if gas.is_wet_gas(): keyword = "PVTG" elif gas.is_dry_gas(): keyword = "PVDG" else: raise NotImplementedError( "The PVT property type of gas is not implemented." ) for region_index, region in enumerate(gas.regions()): if gas.is_wet_gas(): (pressure, ratio) = ( region.get_keys(), region.get_independents(), ) else: (ratio, pressure) = ( region.get_keys(), region.get_independents(), ) column_pvtnum.extend([region_index + 1 for _ in pressure]) column_keyword.extend([keyword for _ in pressure]) column_ratio.extend(ratio) column_pressure.extend(pressure) column_pressure_unit.extend([gas.pressure_unit() for _ in pressure]) column_volume_factor.extend( region.formation_volume_factor(ratio, pressure) ) column_volume_factor_unit.extend( [gas.formation_volume_factor_unit() for _ in pressure] ) column_viscosity.extend(region.viscosity(ratio, pressure)) column_viscosity_unit.extend([gas.viscosity_unit() for _ in pressure]) if water: for region_index, region in enumerate(water.regions()): column_pvtnum.extend([region_index + 1 for _ in pressures]) column_keyword.extend(["PVTW" for _ in pressures]) column_ratio.extend(ratios) column_pressure.extend(pressures) column_pressure_unit.extend([water.pressure_unit() for _ in pressures]) column_volume_factor.extend( region.formation_volume_factor(ratios, pressures) ) column_volume_factor_unit.extend( [water.formation_volume_factor_unit() for _ in pressures] ) column_viscosity.extend(region.viscosity(ratios, pressures)) column_viscosity_unit.extend( [water.viscosity_unit() for _ in pressures] ) data_frame = pd.DataFrame( { "PVTNUM": column_pvtnum, "KEYWORD": column_keyword, "R": column_ratio, "PRESSURE": column_pressure, "PRESSURE_UNIT": column_pressure_unit, "VOLUMEFACTOR": column_volume_factor, "VOLUMEFACTOR_UNIT": column_volume_factor_unit, "VISCOSITY": column_viscosity, "VISCOSITY_UNIT": column_viscosity_unit, } ) return data_frame
def test_write_binary_append(self): npArr1 = np.array([1.1, 2.2e+28, 3.3, 4.4], dtype='float32') npArr2 = np.array([11.11, 12.12, 13.13, 14.14], dtype='float64') npArr3 = np.array([1, 2, 3, 4], dtype='int32') npArr4 = np.array(["PROD1", "", "INJ1"], dtype='str') npArr5 = np.array([True, True, False, True, False, False], dtype='bool') #npArr6=np.array([11,12,13,14], dtype='int64') testFile = test_path("data/RESULT.INIT") # default is binary format (unformatted) and append = false # will create a new file1 out1 = EclOutput(testFile) out1.write("ARR0", npArr1) # append = False (default value), will create a new file, # hence, array ARR0 from out1 will be errased out2 = EclOutput(testFile) out2.write("ARR1", npArr1) # append =True, will add ARR2 to existing file out3 = EclOutput(testFile, append=True) out3.write("ARR2", npArr2) out3.write("ARR3", npArr3) out3.write("ARR4", npArr4) out3.write("ARR5", npArr5) file1 = EclFile(testFile) self.assertEqual(len(file1), 5) # check array ARR1 testArray = file1[0] self.assertEqual(len(testArray), len(npArr1)) for v1, v2 in zip(testArray, npArr1): self.assertEqual(v1, v2) # check array ARR2 testArray = file1[1] self.assertEqual(len(testArray), len(npArr2)) for v1, v2 in zip(testArray, npArr2): self.assertEqual(v1, v2) # check array ARR3 testArray = file1[2] self.assertEqual(len(testArray), len(npArr3)) for v1, v2 in zip(testArray, npArr3): self.assertEqual(v1, v2) # check array ARR4 testArray = file1[3] self.assertEqual(len(testArray), len(npArr4)) for v1, v2 in zip(testArray, npArr4): self.assertEqual(v1, v2) # check array ARR5 testArray = file1[4] self.assertEqual(len(testArray), len(npArr5)) for v1, v2 in zip(testArray, npArr5): self.assertEqual(v1, v2) if os.path.isfile(testFile): os.remove(testFile)
def test_write_strings_formattede(self): testFile = test_path("data/TMP1.FINIT") shortWelNames = ["PROD-1", "PROD-2", "PROD-3", "PROD-4", "PROD-5"] longWelNames = [ "PRODUCER-1", "PRODUCER-2", "PRODUCER-13", "PRODUCER-4" ] out1 = EclOutput(testFile, formatted=True) out1.write("WGNAME", shortWelNames) file1 = EclFile(testFile) array = file1["WGNAME"] self.assertEqual(len(array), len(shortWelNames)) for v1, v2 in zip(array, shortWelNames): self.assertEqual(v1, v2) arrayList = file1.arrays name, arr_type, num = arrayList[0] self.assertEqual(name, "WGNAME") self.assertEqual(arr_type, eclArrType.CHAR) self.assertEqual(num, len(shortWelNames)) out2 = EclOutput(testFile, formatted=True) out2.write("NAMES", longWelNames) file2 = EclFile(testFile) array = file2["NAMES"] self.assertEqual(len(array), len(longWelNames)) for v1, v2 in zip(array, longWelNames): self.assertEqual(v1, v2) arrayList = file2.arrays name, arr_type, num = arrayList[0] self.assertEqual(name, "NAMES") self.assertEqual(arr_type, eclArrType.C0nn) self.assertEqual(num, len(longWelNames)) out3 = EclOutput(testFile, formatted=True) out3.write("NAMES", shortWelNames, C0nn=True) file3 = EclFile(testFile) array = file3["NAMES"] self.assertEqual(len(array), len(shortWelNames)) for v1, v2 in zip(array, shortWelNames): self.assertEqual(v1, v2) arrayList = file3.arrays name, arr_type, num = arrayList[0] self.assertEqual(name, "NAMES") self.assertEqual(arr_type, eclArrType.C0nn) self.assertEqual(num, len(shortWelNames)) if os.path.isfile(testFile): os.remove(testFile)
def from_ecl_init_file(ecl_init_file: EclFile, keep_unit_system: bool = True) -> Optional["Gas"]: """Reads the given Eclipse file and creates a Gas object from its data. Args: ecl_init_file: Eclipse INIT file keep_unit_system: Set to True if the unit system used in the Eclipse file shall be kept, False if SI shall be used. Returns: A Gas object or None if the data in the Eclipse file was invalid """ intehead = ecl_init_file.__getitem__(InitFileDefinitions.INTEHEAD_KW) intehead_phase = intehead[InitFileDefinitions.INTEHEAD_PHASE_INDEX] if (intehead_phase & (1 << 2)) == 0: return None raw = EclPropertyTableRawData() tab_dims = ecl_init_file.__getitem__("TABDIMS") tab = ecl_init_file.__getitem__("TAB") num_rv = tab_dims[InitFileDefinitions.TABDIMS_NRPVTG_ITEM] num_pg = tab_dims[InitFileDefinitions.TABDIMS_NPPVTG_ITEM] raw.num_cols = 5 raw.num_tables = tab_dims[InitFileDefinitions.TABDIMS_NTPVTG_ITEM] if raw.num_tables == 0: return None logihead = ecl_init_file.__getitem__(InitFileDefinitions.LOGIHEAD_KW) if logihead[InitFileDefinitions.LOGIHEAD_RV_INDEX]: raw.num_primary = num_pg raw.num_rows = num_rv else: raw.num_primary = 1 raw.num_rows = num_pg num_tab_elements = raw.num_primary * raw.num_tables start = tab_dims[InitFileDefinitions.TABDIMS_JBPVTG_OFFSET_ITEM] - 1 raw.primary_key = tab[start:start + num_tab_elements] num_tab_elements = (raw.num_primary * raw.num_rows * raw.num_cols * raw.num_tables) start = tab_dims[InitFileDefinitions.TABDIMS_IBPVTG_OFFSET_ITEM] - 1 raw.data = tab[start:start + num_tab_elements] surface_mass_densities = ( surface_mass_density(ecl_init_file, EclPhaseIndex.LIQUID, keep_unit_system), surface_mass_density(ecl_init_file, EclPhaseIndex.VAPOUR, keep_unit_system), ) return Gas( raw, intehead[InitFileDefinitions.INTEHEAD_UNIT_INDEX], surface_mass_densities, keep_unit_system, )