def test_cube_attr_rms_two_surfaces_compare_window(load_cube_rsgy1):
"""Get cube attribute (rms) between two surfaces, and compare with
window."""
xs1 = RegularSurface(rtop1)
xs2 = xs1.copy()
xs2.values += 30
kube = load_cube_rsgy1
xss1 = xs1.copy()
xss1.slice_cube_window(kube,
other=xs2,
other_position='below',
attribute='rms',
sampling='trilinear')
xss2 = xs1.copy()
xss2.values += 15
xss2.slice_cube_window(kube,
zrange=15,
attribute='rms',
sampling='trilinear')
assert xss1.values.mean() == xss2.values.mean()
def test_cube_attr_mean_two_surfaces_with_zeroiso(tmpdir, load_cube_rsgy1):
"""Get cube attribute between two surfaces with partly zero isochore."""
logger.info("Loading surfaces {} {}".format(RTOP1, RBAS1))
xs1 = RegularSurface(RTOP1)
xs2 = RegularSurface(RBAS2)
logger.info("Loading cube {}".format(RSGY1))
kube = load_cube_rsgy1
xss = xs1.copy()
xss.slice_cube_window(
kube, other=xs2, other_position="below", attribute="mean", sampling="trilinear"
)
xss.to_file(join(tmpdir, "surf_slice_cube_2surf_meantri.gri"))
xss.quickplot(
filename=join(tmpdir, "surf_slice_cube_2surf_mean_v2.png"),
colortable="jet",
title="Reek two surfs mean",
minmax=(-0.1, 0.1),
infotext="Method: trilinear, 2 surfs, partly zero isochore",
)
logger.info("Mean is {}".format(xss.values.mean()))
def test_cube_attr_mean_two_surfaces(load_cube_rsgy1):
"""Get cube attribute (mean) between two surfaces."""
logger.info("Loading surfaces {} {}".format(RTOP1, RBAS1))
xs1 = RegularSurface(RTOP1)
xs2 = RegularSurface(RBAS1)
logger.info("Loading cube {}".format(RSGY1))
kube = load_cube_rsgy1
xss = xs1.copy()
xss.slice_cube_window(kube,
other=xs2,
other_position="below",
attribute="mean",
sampling="trilinear")
xss.to_file(td + "/surf_slice_cube_2surf_meantri.gri")
xss.quickplot(
filename=td + "/surf_slice_cube_2surf_mean.png",
colortable="jet",
title="Reek two surfs mean",
minmax=(-0.1, 0.1),
infotext="Method: trilinear, 2 surfs",
)
logger.info("Mean is {}".format(xss.values.mean()))
def test_cube_attr_mean_two_surfaces_with_zeroiso(load_cube_rsgy1):
"""Get cube attribute between two surfaces with partly zero isochore."""
logger.info('Loading surfaces {} {}'.format(rtop1, rbas1))
xs1 = RegularSurface(rtop1)
xs2 = RegularSurface(rbas2)
logger.info('Loading cube {}'.format(rsgy1))
kube = load_cube_rsgy1
xss = xs1.copy()
xss.slice_cube_window(kube,
other=xs2,
other_position='below',
attribute='mean',
sampling='trilinear')
xss.to_file(td + '/surf_slice_cube_2surf_meantri.gri')
xss.quickplot(filename=td + '/surf_slice_cube_2surf_mean_v2.png',
colortable='jet',
title='Reek two surfs mean',
minmax=(-0.1, 0.1),
infotext='Method: trilinear, 2 surfs, partly zero isochore')
logger.info('Mean is {}'.format(xss.values.mean()))
def test_cube_attr_mean_two_surfaces_multiattr(tmpdir, load_cube_rsgy1):
"""Get cube attribute (mean) between two surfaces, many attr at the same
time.
"""
logger.info("Loading surfaces {} {}".format(RTOP1, RBAS1))
xs1 = RegularSurface(RTOP1)
xs2 = RegularSurface(RBAS1)
logger.info("Loading cube {}".format(RSGY1))
kube = load_cube_rsgy1
xss = xs1.copy()
xss.slice_cube_window(
kube,
other=xs2,
other_position="below",
attribute="rms",
sampling="trilinear",
showprogress=True,
)
logger.debug(xss.values.mean())
xsx = xs1.copy()
attrs = xsx.slice_cube_window(
kube,
other=xs2,
other_position="below",
attribute=["max", "mean", "min", "rms"],
sampling="trilinear",
showprogress=True,
)
logger.debug(attrs["rms"].values.mean())
assert xss.values.mean() == attrs["rms"].values.mean()
assert xss.values.std() == attrs["rms"].values.std()
for attr in attrs.keys():
logger.info("Working with %s", attr)
xxx = attrs[attr]
xxx.to_file(join(tmpdir, "surf_slice_cube_2surf_" + attr + "multi.gri"))
minmax = (None, None)
if attr == "mean":
minmax = (-0.1, 0.1)
xxx.quickplot(
filename=join(tmpdir, "surf_slice_cube_2surf_" + attr + "multi.png"),
colortable="jet",
minmax=minmax,
title="Reek two surfs mean multiattr: " + attr,
infotext="Method: trilinear, 2 surfs multiattr " + attr,
)
def test_get_surface_from_cube(load_cube_rsgy1):
"""Construct a constant surface from cube."""
surf = RegularSurface()
cube = load_cube_rsgy1
surf.from_cube(cube, 1999.0)
assert surf.xinc == cube.xinc
assert surf.nrow == cube.nrow
tsetup.assert_almostequal(surf.values.mean(), 1999.0, 0.00001)
def test_slice_attr_window_max(load_cube_rsgy1):
"""Slice a cube within a window, get max, using trilinear interpol."""
logger.info('Loading surface')
xs1 = RegularSurface(rtop1)
logger.info('Loading cube')
kube = load_cube_rsgy1
xs1.slice_cube_window(kube, attribute='max', sampling='trilinear')
logger.info(xs1.values.mean())
tsetup.assert_almostequal(xs1.values.mean(), 0.08494559, 0.0001)
def test_simple_plot():
"""Test as simple map plot only making an instance++ and plot."""
mysurf = RegularSurface()
mysurf.from_file(SFILE1)
# just make the instance, with a lot of defaults behind the scene
myplot = Map()
myplot.canvas(title="My o my")
myplot.colormap = "gist_ncar"
myplot.plot_surface(mysurf)
myplot.savefig("TMP/map_simple.png")
def test_avg02():
"""Make average map from Reek Eclipse."""
grd = Grid()
grd.from_file(GFILE2, fformat="egrid")
# get the poro
po = GridProperty()
po.from_file(IFILE2, fformat="init", name="PORO", grid=grd)
# get the dz and the coordinates
dz = grd.get_dz(mask=False)
xc, yc, _zc = grd.get_xyz(mask=False)
# get actnum
actnum = grd.get_actnum()
# convert from masked numpy to ordinary
xcuse = np.copy(xc.values3d)
ycuse = np.copy(yc.values3d)
dzuse = np.copy(dz.values3d)
pouse = np.copy(po.values3d)
# dz must be zero for undef cells
dzuse[actnum.values3d < 0.5] = 0.0
pouse[actnum.values3d < 0.5] = 0.0
# make a map... estimate from xc and yc
zuse = np.ones((xcuse.shape))
avgmap = RegularSurface(
nx=200,
ny=250,
xinc=50,
yinc=50,
xori=457000,
yori=5927000,
values=np.zeros((200, 250)),
)
avgmap.avg_from_3dprop(
xprop=xcuse,
yprop=ycuse,
zoneprop=zuse,
zone_minmax=(1, 1),
mprop=pouse,
dzprop=dzuse,
truncate_le=None,
)
# add the faults in plot
fau = Polygons(FFILE1, fformat="zmap")
fspec = {"faults": fau}
avgmap.quickplot(filename="TMP/tmp_poro2.png",
xlabelrotation=30,
faults=fspec)
avgmap.to_file("TMP/tmp.poro.gri", fformat="irap_ascii")
logger.info(avgmap.values.mean())
assert avgmap.values.mean() == pytest.approx(0.1653, abs=0.01)
def test_cube_slice_w_ignore_dead_traces_trilinear():
"""Get cube slice trilinear aka Auto4D input, with scrambled data with
dead traces to be ignored, various YFLIP cases."""
cube1 = Cube(XCUB2)
surf1 = RegularSurface()
surf1.from_cube(cube1, 1000.0)
cells = [(18, 12), (20, 2), (0, 4)]
surf1.slice_cube(cube1,
sampling="trilinear",
snapxy=True,
deadtraces=False)
plotfile = ojn(td, "slice_tri1.png")
title = "Cube with dead traces; trilinear; keep as is at dead traces"
surf1.quickplot(filename=plotfile, minmax=(-10000, 10000), title=title)
for cell in cells:
icell, jcell = cell
assert surf1.values[icell,
jcell] == pytest.approx(cube1.values[icell, jcell,
0],
abs=0.1)
assert ma.count_masked(surf1.values) == 0 # shall be no masked cells
def test_cube_attr_mean_two_surfaces_multiattr(load_cube_rsgy1):
"""Get cube attribute (mean) between two surfaces, many attr at the same
time.
"""
logger.info('Loading surfaces {} {}'.format(rtop1, rbas1))
xs1 = RegularSurface(rtop1)
xs2 = RegularSurface(rbas1)
logger.info('Loading cube {}'.format(rsgy1))
kube = load_cube_rsgy1
xss = xs1.copy()
xss.slice_cube_window(kube,
other=xs2,
other_position='below',
attribute='rms',
sampling='trilinear',
showprogress=True)
logger.debug(xss.values.mean())
xsx = xs1.copy()
attrs = xsx.slice_cube_window(kube,
other=xs2,
other_position='below',
attribute=['max', 'mean', 'min', 'rms'],
sampling='trilinear',
showprogress=True)
logger.debug(attrs['rms'].values.mean())
assert xss.values.mean() == attrs['rms'].values.mean()
assert xss.values.std() == attrs['rms'].values.std()
for attr in attrs.keys():
logger.info('Working with %s', attr)
xxx = attrs[attr]
xxx.to_file(ojn(td, 'surf_slice_cube_2surf_' + attr + 'multi.gri'))
minmax = (None, None)
if attr == 'mean':
minmax = (-0.1, 0.1)
xxx.quickplot(filename=ojn(
td, 'surf_slice_cube_2surf_' + attr + 'multi.png'),
colortable='jet',
minmax=minmax,
title='Reek two surfs mean multiattr: ' + attr,
infotext='Method: trilinear, 2 surfs multiattr ' + attr)
def test_map_to_points(reek_map):
"""Get the list of the coordinates"""
px = Points()
surf = RegularSurface(ftop1)
assert isinstance(surf, RegularSurface)
tsetup.assert_almostequal(surf.values.mean(), 0.5755830099, 0.001)
px.from_surface(surf)
# convert to a Points instance
px = Points(reek_map)
# or
# px.from_surface(...)
outf = os.path.join(td, 'points_from_surf_reek.poi')
px.to_file(outf)
assert px.dataframe['X_UTME'].min() == 456719.75
tsetup.assert_almostequal(px.dataframe['Z_TVDSS'].mean(), 0.57558, 0.001)
# read the output for comparison
pxx = Points(outf)
tsetup.assert_almostequal(px.dataframe['Z_TVDSS'].mean(),
pxx.dataframe['Z_TVDSS'].mean(), 0.00001)
def test_cube_attr_rms_two_surfaces_compare_window_show(load_cube_rsgy1):
"""Get cube attribute (rms) between two surfaces, and compare with
window, and show plots."""
logger.info("Loading surfaces {} {}".format(RTOP1, RBAS1))
xs1 = RegularSurface(RTOP1)
xs2 = xs1.copy()
xs2.values += 30
logger.info("Loading cube {}".format(RSGY1))
kube = load_cube_rsgy1
xss1 = xs1.copy()
xss1.slice_cube_window(kube,
other=xs2,
other_position="below",
attribute="rms",
sampling="trilinear")
xss1.quickplot(
filename=td + "/surf_slice_cube_2surf_rms1.png",
colortable="jet",
minmax=[0, 0.5],
# TODO: itle='Reek two surfs mean', minmax=(-0.1, 0.1),
infotext="Method: trilinear, 2 surfs, 30ms apart",
)
print("\n\n{}\n".format("=" * 100))
xss2 = xs1.copy()
xss2.values += 15
xss2.slice_cube_window(kube,
zrange=15,
attribute="rms",
sampling="trilinear")
xss2.quickplot(
filename=td + "/surf_slice_cube_2surf_rms2.png",
colortable="jet",
minmax=[0, 0.5],
# TODO: itle='Reek two surfs mean', minmax=(-0.1, 0.1),
infotext="Method: trilinear, 2 surfs, +- 15ms window",
)
assert xss1.values.mean() == xss2.values.mean()
def test_slice_attr_window_max_algorithm2(load_cube_rsgy1):
"""Slice a cube within a window, get max, using trilinear interpol,
alg 2.
"""
logger.info('Loading surface')
xs1 = RegularSurface(rtop1)
# xs2 = xs1.copy()
# xs3 = xs1.copy()
logger.info('Loading cube')
kube = load_cube_rsgy1
# t1 = xtg.timer()
xs1.slice_cube_window(kube,
attribute='min',
sampling='trilinear',
algorithm=2)
def test_create_surf_distance_log(loadwell1):
"""Test making a log which is distance to a surface."""
well = loadwell1
surf1 = RegularSurface(SURF1)
surf2 = RegularSurface(SURF2)
well.create_surf_distance_log(surf1, name="DIST_TOP")
well.create_surf_distance_log(surf2, name="DIST_BASE")
assert well.dataframe.loc[0, "DIST_TOP"] == pytest.approx(1653.303263)
assert well.dataframe.loc[0, "DIST_BASE"] == pytest.approx(1696.573171)
# moving the surface so it is outside the well
surf1.translate_coordinates((10000, 10000, 0))
well.create_surf_distance_log(surf1, name="DIST_BASE_NEW")
assert np.isnan(well.dataframe.loc[0, "DIST_BASE_NEW"])
def test_cube_attr_rms_two_surfaces_compare_window_show(load_cube_rsgy1):
"""Get cube attribute (rms) between two surfaces, and compare with
window, and show plots."""
logger.info('Loading surfaces {} {}'.format(rtop1, rbas1))
xs1 = RegularSurface(rtop1)
xs2 = xs1.copy()
xs2.values += 30
logger.info('Loading cube {}'.format(rsgy1))
kube = load_cube_rsgy1
xss1 = xs1.copy()
xss1.slice_cube_window(kube,
other=xs2,
other_position='below',
attribute='rms',
sampling='trilinear')
xss1.quickplot(
filename=td + '/surf_slice_cube_2surf_rms1.png',
colortable='jet',
minmax=[0, 0.5],
# TODO: itle='Reek two surfs mean', minmax=(-0.1, 0.1),
infotext='Method: trilinear, 2 surfs, 30ms apart')
print('\n\n{}\n'.format('=' * 100))
xss2 = xs1.copy()
xss2.values += 15
xss2.slice_cube_window(kube,
zrange=15,
attribute='rms',
sampling='trilinear')
xss2.quickplot(
filename=td + '/surf_slice_cube_2surf_rms2.png',
colortable='jet',
minmax=[0, 0.5],
# TODO: itle='Reek two surfs mean', minmax=(-0.1, 0.1),
infotext='Method: trilinear, 2 surfs, +- 15ms window')
assert xss1.values.mean() == xss2.values.mean()
def test_more_features_plot():
"""Map with some more features added, such as label rotation."""
mysurf = RegularSurface()
mysurf.from_file(SFILE1)
myfaults = Polygons(PFILE1)
# just make the instance, with a lot of defaults behind the scene
myplot = Map()
myplot.canvas(title="Label rotation")
myplot.colormap = "rainbow"
myplot.plot_surface(mysurf,
minvalue=1250,
maxvalue=2200,
xlabelrotation=45)
myplot.plot_faults(myfaults)
myplot.savefig(TD + "/map_more1.png")
def test_slice_nearest(tmpdir, load_cube_rsgy1):
"""Slice a cube with a surface, nearest node, algorithm 1"""
xs = RegularSurface(RTOP1)
xs.to_file(join(tmpdir, "surf_slice_cube_initial.gri"))
kube = load_cube_rsgy1
t1 = xtg.timer()
xs.slice_cube(kube, algorithm=1)
logger.info("Slicing...done in {} seconds".format(xtg.timer(t1)))
xs.to_file(join(tmpdir, "surf_slice_cube_v1.gri"), fformat="irap_binary")
xs.quickplot(
filename=join(tmpdir, "surf_slice_cube_near_v1.png"),
colortable="seismic",
minmax=(-1, 1),
title="Reek",
infotext="Method: nearest, algorithm 1",
)
def test_map_plot_with_points():
"""Test as simple map plot with underlying points."""
mysurf = RegularSurface()
mysurf.from_file(SFILE1)
mypoints = Points()
mypoints.from_surface(mysurf)
df = mypoints.dataframe.copy()
df = df[::20]
mypoints.dataframe = df
# just make the instance, with a lot of defaults behind the scene
myplot = Map()
myplot.canvas(title="My o my")
myplot.colormap = "gist_ncar"
myplot.plot_surface(mysurf)
myplot.plot_points(mypoints)
myplot.savefig("TMP/map_with_points.png")
def test_slice_attr_window_max(load_cube_rsgy1):
"""Slice a cube within a window, get max, using trilinear interpol."""
logger.info("Loading surface")
xs1 = RegularSurface(RTOP1)
logger.info("Loading cube")
kube = load_cube_rsgy1
ret = xs1.slice_cube_window(kube,
attribute="max",
sampling="trilinear",
algorithm=2)
logger.info(xs1.values.mean())
assert ret is None
tsetup.assert_almostequal(xs1.values.mean(), 0.08619, 0.001)
# one attribute but in a list context shall return a dict
xs1 = RegularSurface(RTOP1)
ret = xs1.slice_cube_window(kube,
attribute=["max"],
sampling="trilinear",
algorithm=2)
assert isinstance(ret, dict)
tsetup.assert_almostequal(ret["max"].values.mean(), 0.08619, 0.001)
def test_resample(tmpdir, reek_map):
"""Do resampling from one surface to another."""
xs = reek_map
assert xs.ncol == 554
xs_copy = xs.copy()
# create a new map instance, unrotated, based on this map
ncol = int((xs.xmax - xs.xmin) / 10)
nrow = int((xs.ymax - xs.ymin) / 10)
values = np.zeros((nrow, ncol))
snew = RegularSurface(
xori=xs.xmin,
xinc=10,
yori=xs.ymin,
yinc=10,
nrow=nrow,
ncol=ncol,
values=values,
)
snew.resample(xs)
fout = join(tmpdir, "reek_resampled.gri")
snew.to_file(fout, fformat="irap_binary")
tsetup.assert_almostequal(snew.values.mean(), 1698.458, 2)
tsetup.assert_almostequal(snew.values.mean(), xs.values.mean(), 2)
# check that the "other" in snew.resample(other) is unchanged:
assert xs.xinc == xs_copy.xinc
tsetup.assert_almostequal(xs.values.mean(), xs_copy.values.mean(), 1e-4)
tsetup.assert_almostequal(xs.values.std(), xs_copy.values.std(), 1e-4)
def test_avg03():
"""Make average map from Reek Eclipse, speed up by zone_avg."""
g = Grid()
g.from_file(gfile2, fformat="egrid")
# get the poro
po = GridProperty()
po.from_file(ifile2, fformat='init', name='PORO', grid=g)
# get the dz and the coordinates
dz = g.get_dz(mask=False)
xc, yc, zc = g.get_xyz(mask=False)
# get actnum
actnum = g.get_actnum()
actnum = actnum.get_npvalues3d()
# convert from masked numpy to ordinary
xcuse = xc.get_npvalues3d()
ycuse = yc.get_npvalues3d()
dzuse = dz.get_npvalues3d(fill_value=0.0)
pouse = po.get_npvalues3d(fill_value=0.0)
# dz must be zero for undef cells
dzuse[actnum < 0.5] = 0.0
pouse[actnum < 0.5] = 0.0
# make a map... estimate from xc and yc
zuse = np.ones((xcuse.shape))
avgmap = RegularSurface(nx=200, ny=250, xinc=50, yinc=50,
xori=457000, yori=5927000,
values=np.zeros((200, 250)))
avgmap.avg_from_3dprop(xprop=xcuse, yprop=ycuse, zoneprop=zuse,
zone_minmax=(1, 1),
mprop=pouse, dzprop=dzuse,
truncate_le=None, zone_avg=True)
# add the faults in plot
fau = Polygons(ffile1, fformat='zmap')
fspec = {'faults': fau}
avgmap.quickplot(filename='TMP/tmp_poro3.png', xlabelrotation=30,
faults=fspec)
avgmap.to_file('TMP/tmp.poro3.gri', fformat='irap_ascii')
logger.info(avgmap.values.mean())
assert avgmap.values.mean() == pytest.approx(0.1653, abs=0.01)
def test_perm_logarithmic_map():
"""Map with PERM, log scale."""
mysurf = RegularSurface(SFILE2)
myplot = Map()
myplot.canvas(title="PERMX normal scale")
myplot.colormap = "rainbow"
myplot.plot_surface(mysurf,
minvalue=0,
maxvalue=6000,
xlabelrotation=45,
logarithmic=True)
myplot.savefig(TD + "/permx_normal.png")
def test_perm_logarithmic_map():
"""Map with PERM, log scale."""
mysurf = RegularSurface(sfile2)
myplot = Map()
myplot.canvas(title='PERMX normal scale')
myplot.colormap = 'gist_rainbow_r'
myplot.plot_surface(mysurf,
minvalue=0,
maxvalue=6000,
xlabelrotation=45,
logarithmic=True)
myplot.savefig(td + '/permx_normal.png')
def test_resample_small():
"""Do resampling with minimal dataset to test for various yflip etc"""
xs1 = RegularSurface(
xori=0,
yori=0,
ncol=3,
nrow=3,
xinc=100,
yinc=100,
values=-888.0,
yflip=1,
)
xs2 = RegularSurface(
xori=0,
yori=0,
ncol=3,
nrow=3,
xinc=100,
yinc=100,
values=888.0,
yflip=1,
)
xs3 = RegularSurface(
xori=0,
yori=200,
ncol=3,
nrow=3,
xinc=100,
yinc=100,
values=2888.0,
yflip=-1,
)
xsx = xs1.copy()
xsx.resample(xs2)
assert xsx.values.mean() == 888.0
xsx = xs3.copy()
xsx.resample(xs2)
assert xsx.values.mean() == 888.0
xsx = xs1.copy()
xsx.resample(xs3)
assert xsx.values.mean() == 2888.0
def test_resample_partial_sample(tmp_path, reek_map, generate_plot):
"""Do resampling from one surface to another with partial sampling."""
sml = reek_map
# note: values is missing by purpose:
snew = RegularSurface(
ncol=round(sml.ncol * 0.6),
nrow=round(sml.nrow * 0.6),
xori=sml.xori - 2000,
yori=sml.yori + 3000,
xinc=sml.xinc * 0.6,
yinc=sml.xinc * 0.6,
rotation=sml.rotation,
yflip=sml.yflip,
)
print(sml.yflip)
logger.info(snew.values)
snew.resample(sml, mask=True)
assert snew.values.mean() == pytest.approx(1726.65)
if generate_plot:
sml.quickplot(tmp_path / "resampled_input.png")
snew.quickplot(tmp_path / "resampled_output.png")
sml.to_file(tmp_path / "resampled_input.gri")
snew.to_file(tmp_path / "resampled_output.gri")
snew2 = snew.copy()
snew2._yflip = -1
snew2._xori -= 4000
snew2._yori -= 2000
snew2.resample(sml, mask=True)
if generate_plot:
snew2.to_file(tmp_path / "resampled_output2.gri")
assert snew2.values.mean() == pytest.approx(1747.20, abs=0.2)
def test_slice_attr_window_max_w_plotting(load_cube_rsgy1):
"""Slice a cube within a window, get max/min etc, using trilinear
interpol and plotting."""
logger.info("Loading surface")
xs1 = RegularSurface(RTOP1)
xs2 = xs1.copy()
xs3 = xs1.copy()
logger.info("Loading cube")
kube = load_cube_rsgy1
t1 = xtg.timer()
xs1.slice_cube_window(kube, attribute="min", sampling="trilinear")
t2 = xtg.timer(t1)
logger.info("Window slicing... {} secs".format(t2))
xs1.quickplot(
filename=td + "/surf_slice_cube_window_min.png",
colortable="seismic",
minmax=(-1, 1),
title="Reek Minimum",
infotext="Method: trilinear, window",
)
xs2.slice_cube_window(kube,
attribute="max",
sampling="trilinear",
showprogress=True)
xs2.quickplot(
filename=td + "/surf_slice_cube_window_max.png",
colortable="seismic",
minmax=(-1, 1),
title="Reek Maximum",
infotext="Method: trilinear, window",
)
xs3.slice_cube_window(kube, attribute="rms", sampling="trilinear")
xs3.quickplot(
filename=td + "/surf_slice_cube_window_rms.png",
colortable="jet",
minmax=(0, 1),
title="Reek rms (root mean square)",
infotext="Method: trilinear, window",
)
def test_cube_slice_w_dead_traces_nearest():
"""Get cube slice nearest aka Auto4D input, with scrambled data with
dead traces, various YFLIP cases, undef at dead traces."""
cube1 = Cube(xcub2)
surf1 = RegularSurface()
surf1.from_cube(cube1, 1000.1)
cells = ((18, 12), )
surf1.slice_cube(cube1, deadtraces=True)
plotfile = ojn(td, 'slice_nea1_dead.png')
title = 'Cube with dead traces; nearest; UNDEF at dead traces'
surf1.quickplot(filename=plotfile, minmax=(-10000, 10000), title=title)
for cell in cells:
icell, jcell = cell
assert surf1.values[icell, jcell] == cube1.values[icell, jcell, 0]
ndead = (cube1.traceidcodes == 2).sum()
print(ndead)
assert ma.count_masked(surf1.values) == ndead
# swap cube only
surf2 = surf1.copy()
surf2.values = 1000.1
cube2 = cube1.copy()
cube2.swapaxes()
surf2.slice_cube(cube2, deadtraces=True)
plotfile = ojn(td, 'slice_nea1_dead_cubeswap.png')
surf2.quickplot(filename=plotfile, minmax=(-10000, 10000))
assert ma.count_masked(surf2.values) == ndead
assert surf2.values.mean() == surf1.values.mean()
def test_slice_nearest_v2(load_cube_rsgy1):
"""Slice a cube with a surface, nearest node, algorithm 2."""
xs = RegularSurface(RTOP1)
kube = load_cube_rsgy1
t1 = xtg.timer()
xs.slice_cube(kube, algorithm=2)
logger.info("Slicing...done in {} seconds".format(xtg.timer(t1)))
xs.to_file(td + "/surf_slice_cube_alg2.gri", fformat="irap_binary")
xs.quickplot(
filename=td + "/surf_slice_cube_alg2.png",
colortable="seismic",
minmax=(-1, 1),
title="Reek",
infotext="Method: nearest",
)
def test_slice_attr_window_max_w_plotting(load_cube_rsgy1):
"""Slice a cube within a window, get max/min etc, using trilinear
interpol and plotting."""
logger.info('Loading surface')
xs1 = RegularSurface(rtop1)
xs2 = xs1.copy()
xs3 = xs1.copy()
logger.info('Loading cube')
kube = load_cube_rsgy1
t1 = xtg.timer()
xs1.slice_cube_window(kube, attribute='min', sampling='trilinear')
t2 = xtg.timer(t1)
logger.info('Window slicing... {} secs'.format(t2))
xs1.quickplot(filename=td + '/surf_slice_cube_window_min.png',
colortable='seismic',
minmax=(-1, 1),
title='Reek Minimum',
infotext='Method: trilinear, window')
xs2.slice_cube_window(kube,
attribute='max',
sampling='trilinear',
showprogress=True)
xs2.quickplot(filename=td + '/surf_slice_cube_window_max.png',
colortable='seismic',
minmax=(-1, 1),
title='Reek Maximum',
infotext='Method: trilinear, window')
xs3.slice_cube_window(kube, attribute='rms', sampling='trilinear')
xs3.quickplot(filename=td + '/surf_slice_cube_window_rms.png',
colortable='jet',
minmax=(0, 1),
title='Reek rms (root mean square)',
infotext='Method: trilinear, window')
