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,
)
