def test_snap_to_surface():
"""Import XYZ points from file."""
mypoints = xtgeo.Points(PFILE3)
assert mypoints.nrow == 20
surf1 = xtgeo.RegularSurface(SFILE1A)
mypoints.snap_surface(surf1)
assert mypoints.nrow == 11
tsetup.assert_almostequal(mypoints.dataframe["Z_TVDSS"].mean(), 1661.45,
0.01)
# repeat,using surface whithg rotaion and partial masks
mypoints = xtgeo.Points(PFILE3)
surf2 = xtgeo.RegularSurface(SFILE2A)
mypoints.snap_surface(surf2)
assert mypoints.nrow == 12
tsetup.assert_almostequal(mypoints.dataframe["Z_TVDSS"].mean(), 1687.45,
0.01)
# alternative; keep values as is using activeobnly=False
mypoints = xtgeo.Points(PFILE3)
mypoints.snap_surface(surf2, activeonly=False)
assert mypoints.nrow == 20
tsetup.assert_almostequal(mypoints.dataframe["Z_TVDSS"].mean(), 1012.47,
0.01)
mypoints.to_file(join(TMPD, "snapped_point.poi"))
def test_eclunrst_import_soil_reek():
"""Property UNRST import from Eclipse, computing SOIL. Reek"""
gg = Grid(testfile5, fformat='egrid')
logger.info("Import RESTART (UNIFIED) ...")
swat = GridProperty(testfile7,
name='SWAT',
fformat='unrst',
date=19991201,
grid=gg)
tsetup.assert_almostequal(swat.values.mean(), 0.8780, 0.001)
sgas = GridProperty(testfile7,
name='SGAS',
fformat='unrst',
date=19991201,
grid=gg)
tsetup.assert_almostequal(sgas.values.mean(), 0.000, 0.001)
soil = GridProperty(testfile7,
name='SOIL',
fformat='unrst',
date=19991201,
grid=gg)
tsetup.assert_almostequal(soil.values.mean(), 1.0 - 0.8780, 0.001)
def test_irapbin_io():
"""Import and export Irap binary."""
logger.info("Import and export...")
x = xtgeo.RegularSurface()
x.from_file(TESTSET1, fformat="irap_binary")
x.to_file("TMP/reek1_test.fgr", fformat="irap_ascii")
logger.debug("NX is %s", x.ncol)
tsetup.assert_equal(x.ncol, 554)
# get the 1D numpy
v1d = x.get_zval()
logger.info("Mean VALUES are: %s", np.nanmean(v1d))
zval = x.values
# add value via numpy
zval = zval + 300
# update
x.values = zval
tsetup.assert_almostequal(x.values.mean(), 1998.648, 0.01)
x.to_file("TMP/reek1_plus_300_a.fgr", fformat="irap_ascii")
x.to_file("TMP/reek1_plus_300_b.gri", fformat="irap_binary")
mfile = TESTSET1
# direct import
y = xtgeo.RegularSurface(mfile)
tsetup.assert_equal(y.ncol, 554)
# semidirect import
cc = xtgeo.RegularSurface().from_file(mfile)
tsetup.assert_equal(cc.ncol, 554)
def test_import_export_polygons():
"""Import XYZ polygons from file. Modify, and export."""
mypoly = Polygons()
mypoly.from_file(PFILE, fformat="xyz")
z0 = mypoly.dataframe["Z_TVDSS"].values[0]
tsetup.assert_almostequal(z0, 2266.996338, 0.001)
logger.debug(mypoly.dataframe)
mypoly.dataframe["Z_TVDSS"] += 100
mypoly.to_file(TMPD + "/polygon_export.xyz", fformat="xyz")
# reimport and check
mypoly2 = Polygons(TMPD + "/polygon_export.xyz")
tsetup.assert_almostequal(z0 + 100, mypoly2.dataframe["Z_TVDSS"].values[0],
0.001)
def test_reverse_row_axis_dualprops():
"""Reverse axis for distorted but small grid with props"""
grd = Grid(DUALPROPS, fformat="eclipserun", initprops=["PORO", "PORV"])
poro = grd.gridprops.props[0]
logger.info(grd.gridprops.describe())
porowas = poro.copy()
tsetup.assert_almostequal(poro.values[1, 0, 0], 0.17777, 0.01)
assert grd.ijk_handedness == "left"
grd.reverse_row_axis()
tsetup.assert_almostequal(poro.values[1, 2, 0], 0.17777, 0.01)
assert poro.values[1, 2, 0] == porowas.values[1, 0, 0]
grd.reverse_row_axis()
assert poro.values[1, 0, 0] == porowas.values[1, 0, 0]
assert grd.ijk_handedness == "left"
grd.reverse_row_axis(ijk_handedness="left") # ie do nothing in this case
assert poro.values[1, 0, 0] == porowas.values[1, 0, 0]
assert grd.ijk_handedness == "left"
def test_irapbin_import_metadatafirst():
"""Import Reek Irap binary, first with metadata only, then values."""
logger.info("Import and export...")
nsurf = 10
sur = []
t1 = xtg.timer()
for ix in range(nsurf):
sur.append(xtgeo.RegularSurface(TESTSET2, values=False))
t2 = xtg.timer(t1)
logger.info("Loading %s surfaces lazy took %s secs.", nsurf, t2)
assert sur[nsurf - 1].ncol == 1264
t1 = xtg.timer()
for ix in range(nsurf):
sur[ix].load_values()
t2 = xtg.timer(t1)
logger.info("Loading %s surfaces actual values took %s secs.", nsurf, t2)
assert sur[nsurf - 1].ncol == 1264
assert sur[nsurf - 1].nrow == 2010
tsetup.assert_almostequal(sur[nsurf - 1].values[11, 0], 1678.89733887, 0.00001)
def test_get_surfaces_from_3dgrid():
"""Create surfaces from a 3D grid"""
mygrid = xtgeo.Grid(TESTSETG1)
surfs = xtgeo.Surfaces()
surfs.from_grid3d(mygrid, rfactor=2)
surfs.describe()
tsetup.assert_almostequal(surfs.surfaces[-1].values.mean(), 1742.28, 0.04)
tsetup.assert_almostequal(surfs.surfaces[-1].values.min(), 1589.58, 0.04)
tsetup.assert_almostequal(surfs.surfaces[-1].values.max(), 1977.29, 0.04)
tsetup.assert_almostequal(surfs.surfaces[0].values.mean(), 1697.02, 0.04)
for srf in surfs.surfaces:
srf.to_file(join(TMPD, srf.name + ".gri"))
def test_get_surface_from_grd3d_porosity():
"""Sample a surface from a 3D grid"""
surf = xtgeo.surface.RegularSurface(rtop1)
print(surf.values.min(), surf.values.max())
grd = xtgeo.grid3d.Grid(rgrd1, fformat="egrid")
surf.values = 1700
zsurf = surf.copy()
surfr = surf.copy()
surf2 = surf.copy()
phi = xtgeo.grid3d.GridProperty(rprop1,
fformat="init",
name="PORO",
grid=grd)
# slice grd3d
surf.slice_grid3d(grd, phi)
surf.to_file(ojn(td, "surf_slice_grd3d_reek.gri"))
surf.quickplot(filename=ojn(td, "surf_slice_grd3d_reek.png"))
# refined version:
surfr.refine(2)
surfr.slice_grid3d(grd, phi)
surfr.to_file(ojn(td, "surf_slice_grd3d_reek_refined.gri"))
surfr.quickplot(filename=ojn(td, "surf_slice_grd3d_reek_refined.png"))
# use zsurf:
surf2.slice_grid3d(grd, phi, zsurf=zsurf)
surf2.to_file(ojn(td, "surf_slice_grd3d_reek_zslice.gri"))
surf2.quickplot(filename=ojn(td, "surf_slice_grd3d_reek_zslice.png"))
assert np.allclose(surf.values, surf2.values)
tsetup.assert_almostequal(surf.values.mean(), 0.1667, 0.01)
tsetup.assert_almostequal(surfr.values.mean(), 0.1667, 0.01)
def test_randomline_fence_from_well():
"""Import ROFF grid with props and make fences"""
grd = xtgeo.Grid(REEKROOT, fformat="eclipserun", initprops=["PORO"])
wll = xtgeo.Well(WELL1, zonelogname="Zonelog")
print(grd.describe(details=True))
# get the polygon for the well, limit it to 1200
fspec = wll.get_fence_polyline(sampling=10,
nextend=2,
asnumpy=False,
tvdmin=1200)
print(fspec.dataframe)
tsetup.assert_almostequal(fspec.dataframe[fspec.dhname][4], 12.6335, 0.001)
logger.info(fspec.dataframe)
fspec = wll.get_fence_polyline(sampling=10,
nextend=2,
asnumpy=True,
tvdmin=1200)
# get the "image", which is a 2D numpy that can be plotted with e.g. imgshow
hmin, hmax, vmin, vmax, por = grd.get_randomline(fspec,
"PORO",
zmin=1600,
zmax=1700,
zincrement=1.0)
if XTGSHOW:
import matplotlib.pyplot as plt
plt.figure()
plt.imshow(por, cmap="rainbow", extent=(hmin, hmax, vmax, vmin))
plt.axis("tight")
plt.colorbar()
plt.show()
def test_dataframe_more():
"""Get a pandas Dataframe object, more detailed testing"""
xmap = xtgeo.RegularSurface(TESTSET1)
xmap.describe()
dfrc = xmap.dataframe(ijcolumns=True, order="C", activeonly=True)
dfrf = xmap.dataframe(ijcolumns=True, order="F", activeonly=True)
dfrc.to_csv(os.path.join(TMPD, "regsurf_df_c.csv"))
dfrf.to_csv(os.path.join(TMPD, "regsurf_df_f.csv"))
xmap.to_file(os.path.join(TMPD, "regsurf_df.ijxyz"), fformat="ijxyz")
tsetup.assert_almostequal(dfrc["X_UTME"][2], 465956.274, 0.01)
tsetup.assert_almostequal(dfrf["X_UTME"][2], 462679.773, 0.01)
dfrcx = xmap.dataframe(ijcolumns=False, order="C", activeonly=True)
dfrcx.to_csv(os.path.join(TMPD, "regsurf_df_noij_c.csv"))
dfrcy = xmap.dataframe(
ijcolumns=False, order="C", activeonly=False, fill_value=None
)
dfrcy.to_csv(os.path.join(TMPD, "regsurf_df_noij_c_all.csv"))
def test_roffbin_get_dataframe_for_grid(load_gfile1):
"""Import ROFF grid and return a grid dataframe (no props)"""
grd = load_gfile1
assert isinstance(grd, Grid)
df = grd.dataframe()
print(df.head())
assert len(df) == grd.nactive
tsetup.assert_almostequal(df["X_UTME"][0], 459176.7937727844, 0.1)
assert len(df.columns) == 6
df = grd.dataframe(activeonly=False)
print(df.head())
assert len(df.columns) == 7
assert len(df) != grd.nactive
assert len(df) == grd.ncol * grd.nrow * grd.nlay
def test_roffbin_import1(load_gfile1):
"""Test roff binary import case 1"""
grd = load_gfile1
tsetup.assert_equal(grd.ncol, 70, txt="Grid NCOL Emerald")
tsetup.assert_equal(grd.nlay, 46, txt="Grid NLAY Emerald")
# extract ACTNUM parameter as a property instance (a GridProperty)
act = grd.get_actnum()
# get dZ...
dzv = grd.get_dz()
logger.info("ACTNUM is %s", act)
logger.debug("DZ values are \n%s", dzv.values1d[888:999])
dzval = dzv.values
print("DZ mean and shape: ", dzval.mean(), dzval.shape)
# get the value is cell 32 73 1 shall be 2.761
mydz = float(dzval[31:32, 72:73, 0:1])
tsetup.assert_almostequal(mydz, 2.761, 0.001, txt="Grid DZ Emerald")
# get dX dY
logger.info("Get dX dY")
dxv, dyv = grd.get_dxdy()
mydx = float(dxv.values3d[31:32, 72:73, 0:1])
mydy = float(dyv.values3d[31:32, 72:73, 0:1])
tsetup.assert_almostequal(mydx, 118.51, 0.01, txt="Grid DX Emerald")
tsetup.assert_almostequal(mydy, 141.26, 0.01, txt="Grid DY Emerald")
# get X Y Z coordinates (as GridProperty objects) in one go
logger.info("Get X Y Z...")
xvv, yvv, zvv = grd.get_xyz(names=["xxx", "yyy", "zzz"])
tsetup.assert_equal(xvv.name, "xxx", txt="Name of X coord")
xvv.name = "Xerxes"
# attach some properties to grid
grd.props = [xvv, yvv]
logger.info(grd.props)
grd.props = [zvv]
logger.info(grd.props)
grd.props.append(xvv)
logger.info(grd.propnames)
# get the property of name Xerxes
myx = grd.get_prop_by_name("Xerxes")
if myx is None:
logger.info(myx)
else:
logger.info("Got nothing!")
def test_operations_inside_outside_polygon_shortforms():
"""Various shortforms for operations in polygons"""
# assert values are checked in RMS
zurf = xtgeo.surface.RegularSurface(SURF1)
poly = xtgeo.xyz.Polygons(POLY1)
surf = zurf.copy()
surf.add_inside(poly, 200)
tsetup.assert_almostequal(surf.values.mean(), 1759.06, 0.01)
surf = zurf.copy()
surf.add_outside(poly, 200)
tsetup.assert_almostequal(surf.values.mean(), 1838.24, 0.01)
# add another surface inside polygon (here itself)
surf = zurf.copy()
surf2 = zurf.copy()
surf.add_inside(poly, surf2)
tsetup.assert_almostequal(surf.values.mean(), 2206.20, 0.01)
# divide on zero
surf = zurf.copy()
surf.div_inside(poly, 0.0)
surf.to_file("TMP/div2.gri")
surf.to_file("TMP/div2.fgr", fformat="irap_ascii")
# set inside
surf = zurf.copy()
surf.set_inside(poly, 700)
tsetup.assert_almostequal(surf.values.mean(), 1402.52, 0.01)
# eliminate inside
surf = zurf.copy()
surf.eli_inside(poly)
tsetup.assert_almostequal(surf.values.mean(), 1706.52, 0.01)
def test_cube_get_xy_from_ij(loadsfile1):
"""Import a cube, then report XY for a given IJ"""
logger.info("Checking get xy from IJ")
incube = loadsfile1
# thinning to evey second column and row, but not vertically
xpos, ypos = incube.get_xy_value_from_ij(0, 0, zerobased=True)
assert xpos == incube.xori
assert ypos == incube.yori
xpos, ypos = incube.get_xy_value_from_ij(1, 1, zerobased=False)
assert xpos == incube.xori
assert ypos == incube.yori
xpos, ypos = incube.get_xy_value_from_ij(0, 0, ixline=True)
assert xpos == incube.xori
assert ypos == incube.yori
xpos, ypos = incube.get_xy_value_from_ij(200, 200, zerobased=True)
tsetup.assert_almostequal(xpos, 463327.8811957213, 0.01)
tsetup.assert_almostequal(ypos, 5933633.598034564, 0.01)
def test_fill():
"""Fill the undefined values for the surface"""
srf = xtgeo.RegularSurface()
srf.from_file(TESTSET1, fformat="irap_binary")
minv1 = srf.values.min()
tsetup.assert_almostequal(srf.values.mean(), 1698.648, 0.001)
srf.fill()
minv2 = srf.values.min()
tsetup.assert_almostequal(srf.values.mean(), 1705.201, 0.001)
tsetup.assert_almostequal(minv1, minv2, 0.000001)
srf = xtgeo.RegularSurface()
srf.from_file(TESTSET1, fformat="irap_binary")
srf.fill(444)
tsetup.assert_almostequal(srf.values.mean(), 1342.10498, 0.001)
def test_polygon_boundary():
"""Import XYZ polygons from file and test boundary function."""
mypoly = Polygons()
mypoly.from_file(PFILE, fformat="xyz")
boundary = mypoly.get_boundary()
tsetup.assert_almostequal(boundary[0], 460595.6036, 0.0001)
tsetup.assert_almostequal(boundary[4], 2025.952637, 0.0001)
tsetup.assert_almostequal(boundary[5], 2266.996338, 0.0001)
def test_get_xy_values1d():
"""Get the XY coordinate values"""
xmap = xtgeo.RegularSurface()
xcv, _ycv = xmap.get_xy_values1d(activeonly=False, order="C")
tsetup.assert_almostequal(xcv[1], 0.0, 0.001)
xcv, _ycv = xmap.get_xy_values1d(activeonly=False, order="F")
tsetup.assert_almostequal(xcv[1], 25.0, 0.001)
xcv, _ycv = xmap.get_xy_values1d(activeonly=True, order="C")
tsetup.assert_almostequal(xcv[1], 0.0, 0.001)
xcv, _ycv = xmap.get_xy_values1d(activeonly=True, order="F")
tsetup.assert_almostequal(xcv[1], 25.0, 0.001)
def test_get_xy_values():
"""Get the XY coordinate values as 2D arrays"""
xmap = xtgeo.RegularSurface()
xcv, _ycv = xmap.get_xy_values(order="C")
xxv = xcv.ravel(order="K")
tsetup.assert_almostequal(xxv[1], 0.0, 0.001)
xcv, _ycv = xmap.get_xy_values(order="F")
xxv = xcv.ravel(order="K")
tsetup.assert_almostequal(xxv[1], 25.0, 0.001)
xcv, _ycv = xmap.get_xy_values(order="C", asmasked=True)
xxv = xcv.ravel(order="K")
tsetup.assert_almostequal(xxv[1], 0.0, 0.001)
xcv, _ycv = xmap.get_xy_values(order="F", asmasked=True)
xxv = xcv.ravel(order="K")
tsetup.assert_almostequal(xxv[1], 25.0, 0.001)
def test_eclunrst_import_soil_reek():
"""Property UNRST import from Eclipse, computing SOIL. Reek"""
gg = Grid(TESTFILE5, fformat="egrid")
logger.info("Import RESTART (UNIFIED) ...")
swat = GridProperty(TESTFILE7, name="SWAT", fformat="unrst", date=19991201, grid=gg)
tsetup.assert_almostequal(swat.values.mean(), 0.8780, 0.001)
sgas = GridProperty(TESTFILE7, name="SGAS", fformat="unrst", date=19991201, grid=gg)
tsetup.assert_almostequal(sgas.values.mean(), 0.000, 0.001)
soil = GridProperty(TESTFILE7, name="SOIL", fformat="unrst", date=19991201, grid=gg)
tsetup.assert_almostequal(soil.values.mean(), 1.0 - 0.8780, 0.001)
def test_geometrics_reek():
"""Import Reek and test geometrics"""
grd = Grid(REEKFILE, fformat="egrid")
geom = grd.get_geometrics(return_dict=True, cellcenter=False)
for key, val in geom.items():
logger.info("%s is %s", key, val)
# compared with RMS info:
tsetup.assert_almostequal(geom["xmin"], 456510.6, 0.1, "Xmin")
tsetup.assert_almostequal(geom["ymax"], 5938935.5, 0.1, "Ymax")
# cellcenter True:
geom = grd.get_geometrics(return_dict=True, cellcenter=True)
tsetup.assert_almostequal(geom["xmin"], 456620, 1, "Xmin cell center")
def test_dataframe_simple():
"""Get a pandas Dataframe object"""
xmap = xtgeo.RegularSurface(TESTSET1)
dfrc = xmap.dataframe(ijcolumns=True, order="C", activeonly=True)
tsetup.assert_almostequal(dfrc["X_UTME"][2], 465956.274, 0.01)
xmap = xtgeo.surface_from_file(TESTSET2)
dfrc = xmap.dataframe()
tsetup.assert_almostequal(dfrc["X_UTME"][2], 461582.562498, 0.01)
xmap.coarsen(2)
dfrc = xmap.dataframe()
tsetup.assert_almostequal(dfrc["X_UTME"][2], 461577.5575, 0.01)
def test_twosurfaces_oper():
"""Test operations between two surface in more different ways"""
surf1 = xtgeo.RegularSurface(TESTSET1)
surf2 = xtgeo.RegularSurface(TESTSET1A)
iso1 = surf2.copy()
iso1.values -= surf1.values
iso1mean = iso1.values.mean()
tsetup.assert_almostequal(iso1mean, 43.71, 0.01)
iso2 = surf2.copy()
iso2.subtract(surf1)
iso2mean = iso2.values.mean()
tsetup.assert_almostequal(iso2mean, 43.71, 0.01)
assert iso1.values.all() == iso2.values.all()
iso3 = surf2 - surf1
assert iso1.values.all() == iso3.values.all()
assert isinstance(iso3, xtgeo.RegularSurface)
sum1 = surf2.copy()
sum1.values += surf1.values
tsetup.assert_almostequal(sum1.values.mean(), 3441.0, 0.01)
sum2 = surf2.copy()
sum2.add(surf1)
assert sum1.values.all() == sum2.values.all()
sum3 = surf1 + surf2
assert sum1.values.all() == sum3.values.all()
zrf2 = surf2.copy()
zrf1 = surf1.copy()
newzrf1 = surf1.copy()
newzrf1.values = zrf2.values / zrf1.values
assert newzrf1.values.mean() == pytest.approx(1.0257, abs=0.01)
def test_create_shoebox():
"""Make a shoebox grid from scratch"""
grd = xtgeo.Grid()
grd.create_box()
grd.to_file(join(TMPDIR, "shoebox_default.roff"))
grd.create_box(flip=-1)
grd.to_file(join(TMPDIR, "shoebox_default_flipped.roff"))
timer1 = xtg.timer()
grd.create_box(origin=(0, 0, 1000),
dimension=(300, 200, 30),
increment=(20, 20, 1),
flip=-1)
logger.info("Making a a 1,8 mill cell grid took %5.3f secs",
xtg.timer(timer1))
dx, dy = grd.get_dxdy()
tsetup.assert_almostequal(dx.values.mean(), 20.0, 0.0001)
tsetup.assert_almostequal(dy.values.mean(), 20.0, 0.0001)
grd.create_box(origin=(0, 0, 1000),
dimension=(30, 30, 3),
rotation=45,
increment=(20, 20, 1))
x, y, z = grd.get_xyz()
tsetup.assert_almostequal(x.values1d[0], 0.0, 0.001)
tsetup.assert_almostequal(y.values1d[0], 20 * math.cos(45 * math.pi / 180),
0.001)
tsetup.assert_almostequal(z.values1d[0], 1000.5, 0.001)
grd.create_box(
origin=(0, 0, 1000),
dimension=(30, 30, 3),
rotation=45,
increment=(20, 20, 1),
oricenter=True,
)
x, y, z = grd.get_xyz()
tsetup.assert_almostequal(x.values1d[0], 0.0, 0.001)
tsetup.assert_almostequal(y.values1d[0], 0.0, 0.001)
tsetup.assert_almostequal(z.values1d[0], 1000.0, 0.001)
def test_import_dualperm_grid_soil():
"""Test grid with flag for dual perm setup (will also mean dual poro also)"""
grd = xtgeo.grid_from_file(DUALFILE2 + ".EGRID")
grd._dualactnum.to_file("TMP/dualact.roff")
sgas = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SGAS",
date=20170121,
fracture=False)
sgas.describe()
tsetup.assert_almostequal(sgas.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(sgas.values[0, 1, 0], 0.0, 0.001)
soil = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SOIL",
date=20170121,
fracture=False)
soil.describe()
tsetup.assert_almostequal(soil.values[3, 0, 0], 0.44525, 0.001)
tsetup.assert_almostequal(soil.values[0, 1, 0], 0.0, 0.001)
tsetup.assert_almostequal(soil.values[3, 2, 0], 0.0, 0.0001)
# fractures
sgas = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SGAS",
date=20170121,
fracture=True)
tsetup.assert_almostequal(sgas.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(sgas.values[0, 1, 0], 0.0, 0.0001)
soil = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SOIL",
date=20170121,
fracture=True)
tsetup.assert_almostequal(soil.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(soil.values[0, 1, 0], 0.011741, 0.0001)
tsetup.assert_almostequal(soil.values[3, 2, 0], 0.11676, 0.0001)
def test_import_dualperm_grid_sgas():
"""Test grid with flag for dual perm/poro setup gas/water"""
grd = xtgeo.grid_from_file(DUALFILE3 + ".EGRID")
sgas = xtgeo.gridproperty_from_file(DUALFILE3 + ".UNRST",
grid=grd,
name="SGAS",
date=20170121,
fracture=False)
sgas.describe()
tsetup.assert_almostequal(sgas.values[3, 0, 0], 0.06639, 0.001)
tsetup.assert_almostequal(sgas.values[0, 1, 0], 0.0, 0.001)
tsetup.assert_almostequal(sgas.values[4, 2, 0], 0.10696, 0.001)
assert "SGASM in sgas.name"
swat = xtgeo.gridproperty_from_file(DUALFILE3 + ".UNRST",
grid=grd,
name="SWAT",
date=20170121,
fracture=False)
swat.describe()
tsetup.assert_almostequal(swat.values[3, 0, 0], 0.93361, 0.001)
tsetup.assert_almostequal(swat.values[0, 1, 0], 0.0, 0.001)
tsetup.assert_almostequal(swat.values[4, 2, 0], 0.89304, 0.001)
assert "SWATM in swat.name"
# shall be not soil actually
soil = xtgeo.gridproperty_from_file(DUALFILE3 + ".UNRST",
grid=grd,
name="SOIL",
date=20170121,
fracture=False)
soil.describe()
tsetup.assert_almostequal(soil.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(soil.values[0, 1, 0], 0.0, 0.001)
assert "SOILM" in soil.name
# fractures
sgas = xtgeo.gridproperty_from_file(DUALFILE3 + ".UNRST",
grid=grd,
name="SGAS",
date=20170121,
fracture=True)
sgas.describe()
tsetup.assert_almostequal(sgas.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(sgas.values[0, 1, 0], 0.0018198, 0.001)
tsetup.assert_almostequal(sgas.values[4, 2, 0], 0.17841, 0.001)
assert "SGASF" in sgas.name
swat = xtgeo.gridproperty_from_file(DUALFILE3 + ".UNRST",
grid=grd,
name="SWAT",
date=20170121,
fracture=True)
swat.describe()
tsetup.assert_almostequal(swat.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(swat.values[0, 1, 0], 0.99818, 0.001)
tsetup.assert_almostequal(swat.values[4, 2, 0], 0.82159, 0.001)
assert "SWATF" in swat.name
# shall be not soil actually
soil = xtgeo.gridproperty_from_file(DUALFILE3 + ".UNRST",
grid=grd,
name="SOIL",
date=20170121,
fracture=True)
soil.describe()
tsetup.assert_almostequal(soil.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(soil.values[0, 1, 0], 0.0, 0.001)
assert "SOILF" in soil.name
def test_import_dualporo_grid():
"""Test grid with flag for dual porosity setup, oil water"""
grd = xtgeo.grid_from_file(DUALFILE1 + ".EGRID")
assert grd.dualporo is True
assert grd.dualperm is False
assert grd.dimensions == (5, 3, 1)
poro = xtgeo.gridproperty_from_file(DUALFILE1 + ".INIT",
grid=grd,
name="PORO")
tsetup.assert_almostequal(poro.values[0, 0, 0], 0.1, 0.001)
tsetup.assert_almostequal(poro.values[1, 1, 0], 0.16, 0.001)
tsetup.assert_almostequal(poro.values[4, 2, 0], 0.24, 0.001)
assert poro.name == "POROM"
poro.describe()
poro = xtgeo.gridproperty_from_file(DUALFILE1 + ".INIT",
grid=grd,
name="PORO",
fracture=True)
tsetup.assert_almostequal(poro.values[0, 0, 0], 0.25, 0.001)
tsetup.assert_almostequal(poro.values[4, 2, 0], 0.39, 0.001)
assert poro.name == "POROF"
poro.describe()
swat = xtgeo.gridproperty_from_file(DUALFILE1 + ".UNRST",
grid=grd,
name="SWAT",
date=20170121,
fracture=False)
swat.describe()
tsetup.assert_almostequal(swat.values[0, 0, 0], 0.60924, 0.001)
swat = xtgeo.gridproperty_from_file(DUALFILE1 + ".UNRST",
grid=grd,
name="SWAT",
date=20170121,
fracture=True)
swat.describe()
tsetup.assert_almostequal(swat.values[0, 0, 0], 0.989687, 0.001)
swat.to_file("TMP/swat.roff")
def test_import_dualperm_grid():
"""Test grid with flag for dual perm setup (hence dual poro also) water/oil"""
grd = xtgeo.grid_from_file(DUALFILE2 + ".EGRID")
assert grd.dualporo is True
assert grd.dualperm is True
assert grd.dimensions == (5, 3, 1)
grd.to_file(os.path.join(TMPDIR, "dual2.roff"))
poro = xtgeo.gridproperty_from_file(DUALFILE2 + ".INIT",
grid=grd,
name="PORO")
print(poro.values)
tsetup.assert_almostequal(poro.values[0, 0, 0], 0.1, 0.001)
tsetup.assert_almostequal(poro.values[1, 1, 0], 0.16, 0.001)
tsetup.assert_almostequal(poro.values[4, 2, 0], 0.24, 0.001)
assert poro.name == "POROM"
poro.describe()
poro = xtgeo.gridproperty_from_file(DUALFILE2 + ".INIT",
grid=grd,
name="PORO",
fracture=True)
tsetup.assert_almostequal(poro.values[0, 0, 0], 0.25, 0.001)
tsetup.assert_almostequal(poro.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(poro.values[4, 2, 0], 0.39, 0.001)
assert poro.name == "POROF"
poro.describe()
perm = xtgeo.gridproperty_from_file(DUALFILE2 + ".INIT",
grid=grd,
name="PERMX")
tsetup.assert_almostequal(perm.values[0, 0, 0], 100.0, 0.001)
tsetup.assert_almostequal(perm.values[3, 0, 0], 100.0, 0.001)
tsetup.assert_almostequal(perm.values[0, 1, 0], 0.0, 0.001)
tsetup.assert_almostequal(perm.values[4, 2, 0], 100, 0.001)
assert perm.name == "PERMXM"
perm.to_file(os.path.join(TMPDIR, "dual2_permxm.roff"))
perm = xtgeo.gridproperty_from_file(DUALFILE2 + ".INIT",
grid=grd,
name="PERMX",
fracture=True)
tsetup.assert_almostequal(perm.values[0, 0, 0], 100.0, 0.001)
tsetup.assert_almostequal(perm.values[3, 0, 0], 0.0, 0.001)
tsetup.assert_almostequal(perm.values[0, 1, 0], 100.0, 0.001)
tsetup.assert_almostequal(perm.values[4, 2, 0], 100, 0.001)
assert perm.name == "PERMXF"
perm.to_file(os.path.join(TMPDIR, "dual2_permxf.roff"))
swat = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SWAT",
date=20170121,
fracture=False)
tsetup.assert_almostequal(swat.values[3, 0, 0], 0.55475, 0.001)
soil = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SOIL",
date=20170121,
fracture=False)
print(soil.values)
tsetup.assert_almostequal(soil.values[3, 0, 0], 0.44525, 0.001)
tsetup.assert_almostequal(soil.values[0, 1, 0], 0.0, 0.001)
assert np.ma.is_masked(soil.values[1, 2, 0])
tsetup.assert_almostequal(soil.values[3, 2, 0], 0.0, 0.001)
tsetup.assert_almostequal(soil.values[4, 2, 0], 0.41271, 0.001)
swat = xtgeo.gridproperty_from_file(DUALFILE2 + ".UNRST",
grid=grd,
name="SWAT",
date=20170121,
fracture=True)
swat.describe()
assert "SWATF" in swat.name
tsetup.assert_almostequal(swat.values[3, 0, 0], 0.0, 0.001)
swat.to_file("TMP/swat.roff")
