def test_topology(): """Testing topology between two surfaces.""" logger.info("Test if surfaces are similar...") mfile = TESTSET1 x = xtgeo.RegularSurface(mfile) y = xtgeo.RegularSurface(mfile) status = x.compare_topology(y) assert status is True y.xori = y.xori - 100.0 status = x.compare_topology(y) assert status is False
def test_irapbin_import1_engine_python(): """Import Reek Irap binary using python read engine""" logger.info("Import and export...") xsurf = xtgeo.RegularSurface(TESTSET2, fformat="irap_binary", engine="python") assert xsurf.ncol == 1264 assert xsurf.nrow == 2010 tsetup.assert_almostequal(xsurf.values[11, 0], 1678.89733887, 0.001) tsetup.assert_almostequal(xsurf.values[1263, 2009], 1893.75, 0.01) xsurf2 = xtgeo.RegularSurface(TESTSET2, fformat="irap_binary", engine="cxtgeo") assert xsurf.values.mean() == xsurf2.values.mean()
def test_surface_comparisons(): """Test the surface comparison overload""" surf1 = xtgeo.RegularSurface() id1 = id(surf1) surf2 = surf1.copy() cmp = surf1 == surf2 np.testing.assert_equal(cmp, True) cmp = surf1 != surf2 np.testing.assert_equal(cmp, False) cmp = surf1 <= surf2 np.testing.assert_equal(cmp, True) cmp = surf1 < surf2 np.testing.assert_equal(cmp, False) cmp = surf1 > surf2 np.testing.assert_equal(cmp, False) surf2.values[0, 0] = -2 cmp = surf1 == surf2 assert bool(cmp[0, 0]) is False assert id(surf1) == id1
def test_get_randomline_frompolygon(): fence = xtgeo.Polygons(FENCE1) xs = xtgeo.RegularSurface(TESTSET1) # get the polygon fspec = fence.get_fence(distance=10, nextend=2, asnumpy=False) tsetup.assert_almostequal(fspec.dataframe[fspec.dhname][4], 10, 1) fspec = fence.get_fence(distance=20, nextend=5, asnumpy=True) arr = xs.get_randomline(fspec) x = arr[:, 0] y = arr[:, 1] print(arr) print(arr.shape) if XTGSHOW: import matplotlib.pyplot as plt plt.figure() plt.plot(x, y) plt.gca().invert_yaxis() plt.show()
def test_set_values1d(): """Test behaviour of set_values1d method""" srf = xtgeo.RegularSurface() new = srf.copy() assert np.ma.count_masked(new.values) == 1 # values is a new np array; hence old mask shall not be reused vals = np.zeros((new.dimensions)) + 100 vals[1, 1] = srf.undef new.set_values1d(vals.ravel()) assert not np.array_equal(srf.values.mask, new.values.mask) assert np.ma.count_masked(new.values) == 1 # values are modified from existing, hence mask will be additive new = srf.copy() vals = new.values.copy() vals[vals < 2] = new.undef new.values = vals assert np.ma.count_masked(new.values) == 2 # values are modified from existing and set via set_values1d new = srf.copy() vals = new.values.copy() vals = vals.flatten() vals[vals < 2] = new.undef assert np.ma.count_masked(vals) == 1 new.set_values1d(vals) assert np.ma.count_masked(new.values) == 2
def test_detect_fformat_hdf_stream(testpath, filename): stream = io.BytesIO() surf = xtgeo.RegularSurface(testpath / filename) surf.to_hdf(stream) sfile = xtgeo._XTGeoFile(stream) assert sfile.memstream is True assert sfile.detect_fformat() == "hdf"
def test_fence(): """Test sampling a fence from a surface.""" myfence = np.array([ [462174.6191406, 5930073.3461914, 721.711059], [462429.4677734, 5930418.2055664, 720.909423], [462654.6738281, 5930883.9331054, 712.587158], [462790.8710937, 5931501.4443359, 676.873901], [462791.5273437, 5932040.4306640, 659.938476], [462480.2958984, 5932846.7387695, 622.102172], [462226.7070312, 5933397.8632812, 628.067138], [462214.4921875, 5933753.4936523, 593.260864], [462161.5048828, 5934327.8398437, 611.253540], [462325.0673828, 5934688.7519531, 626.485107], [462399.0429687, 5934975.2934570, 640.868774], ]) logger.debug("NP:") logger.debug(myfence) print(myfence) x = xtgeo.RegularSurface(TESTSET1) newfence = x.get_fence(myfence) logger.debug("updated NP:") logger.debug(newfence) print(newfence) tsetup.assert_almostequal(newfence[1][2], 1720.9094, 0.01)
def test_get_randomline_frompolygon(xtgshow): """Test randomline with both bilinear and nearest sampling for surfaces.""" fence = xtgeo.Polygons(FENCE1) xs = xtgeo.RegularSurface(TESTSET1) # get the polygon fspec = fence.get_fence(distance=10, nextend=2, asnumpy=False) assert_almostequal(fspec.dataframe[fspec.dhname][4], 10, 1) fspec = fence.get_fence(distance=20, nextend=5, asnumpy=True) arr1 = xs.get_randomline(fspec) arr2 = xs.get_randomline(fspec, sampling="nearest") x = arr1[:, 0] y1 = arr1[:, 1] y2 = arr2[:, 1] assert y1.mean() == pytest.approx(1706.7514, abs=0.001) assert y2.mean() == pytest.approx(1706.6995, abs=0.001) if xtgshow: import matplotlib.pyplot as plt plt.figure() plt.plot(x, y1) plt.plot(x, y2) plt.gca().invert_yaxis() plt.show()
def test_detect_fformat_hdf_to_file(tmp_path, testpath, filename): newfile = tmp_path / "hdf_surf.hdf" surf = xtgeo.RegularSurface(testpath / filename) surf.to_hdf(newfile) gfile = xtgeo._XTGeoFile(newfile) assert gfile.detect_fformat() == "hdf" assert gfile.detect_fformat(details=True) == "hdf RegularSurface xtgeo"
def sum_running_stats_bytestream(): """Find avg per realisation and do a cumulative rolling mean. Memory consumption shall be very low. """ for irel in range(NRUN): # load as Eclipse run; this will look for EGRID, INIT, UNRST print("Loading realization no {}".format(irel)) with open(EXPATH1, "rb") as myfile: stream = io.BytesIO(myfile.read()) srf = xtgeo.RegularSurface(stream, fformat="irap_binary") nnum = float(irel + 1) srf.values += irel * 1 # just to mimic variability if irel == 0: pcum = srf.values1d else: pavg = srf.values1d / nnum pcum = pcum * (nnum - 1) / nnum pcum = npma.vstack([pcum, pavg]) pcum = pcum.sum(axis=0) # find the averages: print(pcum) print(pcum.mean()) return pcum.mean()
def test_irapbin_import_metadatafirst_simple(): srf = xtgeo.RegularSurface(TESTSET2, values=False) assert set(srf.values.data.flatten().tolist()) == {0.0} assert srf.ncol == 1264 srf.load_values() assert srf.values.mean() == pytest.approx(1672.8242448561361)
def test_fence_sampling(infence, sampling, expected): """Test a very simple fence with different sampling methods.""" surf = xtgeo.RegularSurface() myfence = np.array(infence) myfence[myfence == -999] = np.nan newfence = surf.get_fence(myfence, sampling=sampling) assert np.allclose(newfence[:, 2], expected, equal_nan=True)
def test_get_regsurff(): sfile = TESTSET1 logger.info("File is %s", sfile) for _itmp in range(20): rf = xtgeo.RegularSurface(sfile, fformat="irap_binary") assert abs(rf.values.mean() - 1698.648) < 0.01 print(_itmp)
def test_get_well_x_surf(): """Getting XYZ, MD for well where crossing a surface""" wll = xtgeo.Well(WFILE, mdlogname="Q_MDEPTH") surf = xtgeo.RegularSurface(SFILE) top = wll.get_surface_picks(surf) assert top.dataframe.Q_MDEPTH[5] == pytest.approx(5209.636860, abs=0.001)
def fixture_regsurf(): """Create an xtgeo surface.""" logger.info("Ran %s", inspect.currentframe().f_code.co_name) return xtgeo.RegularSurface(ncol=12, nrow=10, xinc=20, yinc=20, values=1234.0)
def test_create_init_mixlist(): """Create simple Surfaces instance, initiate with a list of files.""" top = xtgeo.RegularSurface(TESTSET1A) flist = [top, TESTSET1B] surfs = xtgeo.Surfaces(flist) assert isinstance(surfs.surfaces[0], xtgeo.RegularSurface) assert isinstance(surfs, xtgeo.Surfaces)
def test_ijxyz_import3(): """Import some IJ XYZ small set yet again""" logger.info("Import and export...") xsurf = xtgeo.RegularSurface() xsurf.from_file(TESTSET4C, fformat="ijxyz") xsurf.describe() xsurf.to_file(os.path.join(TMPD, "ijxyz_set4c.gri"))
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)
def test_surface_file_roundtrip_stream(testpath, filename): stream = io.BytesIO() surf = xtgeo.RegularSurface(testpath / filename) surf.to_file(stream) stream_file = xtgeo._XTGeoFile(stream) assert stream_file.memstream is True assert stream_file.detect_fformat() == "irap_binary"
def test_irapasc_import1(): """Import Reek Irap ascii.""" logger.info("Import and export...") xsurf = xtgeo.RegularSurface(TESTSET3, fformat="irap_ascii") assert xsurf.ncol == 1264 assert xsurf.nrow == 2010 tsetup.assert_almostequal(xsurf.values[11, 0], 1678.89733887, 0.00001) tsetup.assert_almostequal(xsurf.values[1263, 2009], 1893.75, 0.01)
def test_irapasc_io_engine_python(): """Test IO using pure python read/write""" xsurf1 = xtgeo.RegularSurface() usefile1 = os.path.join(TMPD, "surf3a.fgr") usefile2 = os.path.join(TMPD, "surf3b.fgr") print(xsurf1[1, 1]) xsurf1.to_file(usefile1, fformat="irap_ascii", engine="cxtgeo") xsurf1.to_file(usefile2, fformat="irap_ascii", engine="python") xsurf2 = xtgeo.RegularSurface(usefile2, fformat="irap_ascii", engine="python") xsurf3 = xtgeo.RegularSurface(usefile2, fformat="irap_ascii", engine="cxtgeo") assert xsurf1.ncol == xsurf3.ncol == xsurf3.ncol assert xsurf1.values[1, 1] == xsurf2.values[1, 1] == xsurf3.values[1, 1]
def save_statistical_surface(fns: List[str], calculation: str) -> io.BytesIO: """Wrapper function to store a calculated surface as BytesIO""" surfaces = xtgeo.Surfaces(fns) if len(surfaces.surfaces) == 0: surface = xtgeo.RegularSurface(ncol=1, nrow=1, xinc=1, yinc=1) # 1's as input is required elif calculation in ["Mean", "StdDev", "Min", "Max", "P10", "P90"]: # Suppress numpy warnings when surfaces have undefined z-values with warnings.catch_warnings(): warnings.filterwarnings("ignore", "All-NaN slice encountered") warnings.filterwarnings("ignore", "Mean of empty slice") warnings.filterwarnings("ignore", "Degrees of freedom <= 0 for slice") surface = get_statistical_surface(surfaces, calculation) else: surface = xtgeo.RegularSurface(ncol=1, nrow=1, xinc=1, yinc=1) # 1's as input is required return io.BytesIO(surface_to_json(surface).encode())
def test_irapasc_import1_engine_python(): """Import Reek Irap ascii using python read engine""" logger.info("Import and export...") xsurf = xtgeo.RegularSurface(TESTSET3, fformat="irap_ascii", engine="python") assert xsurf.ncol == 1264 assert xsurf.nrow == 2010 assert_almostequal(xsurf.values[11, 0], 1678.89733887, 0.001) assert_almostequal(xsurf.values[1263, 2009], 1893.75, 0.01)
def test_irapbin_import_use_pathib(): """Import Reek Irap binary.""" logger.info("Import and export...") pobj = Path(TESTSET2) xsurf = xtgeo.RegularSurface(pobj) assert xsurf.ncol == 1264 assert xsurf.nrow == 2010
def _get_regsurff(i): logger.info("Start %s", i) sfile = TESTFILE logger.info("File is %s", sfile) rf = xtgeo.RegularSurface(sfile) logger.info("End %s", i) return rf
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_unrotate(): """Change a rotated map to an unrotated instance""" x = xtgeo.RegularSurface() x.from_file(TESTSET1, fformat="irap_binary") logger.info(x) x.unrotate() logger.info(x)
def test_distance_from_point(): """Distance from point.""" x = xtgeo.RegularSurface() x.from_file(TESTSET1, fformat="irap_binary") x.distance_from_point(point=(464960, 7336900), azimuth=30) x.to_file("TMP/reek1_dist_point.gri", fformat="irap_binary")
def test_irapbin_import1(): """Import Reek Irap binary.""" logger.info("Import and export...") xsurf = xtgeo.RegularSurface(TESTSET2) assert xsurf.ncol == 1264 assert xsurf.nrow == 2010 tsetup.assert_almostequal(xsurf.values[11, 0], 1678.89733887, 0.00001) tsetup.assert_almostequal(xsurf.values[1263, 2009], 1893.75, 0.01) xsurf.describe()
def test_similarity(): """Testing similarity of two surfaces. 0.0 means identical in terms of mean value. """ logger.info("Test if surfaces are similar...") mfile = TESTSET1 x = xtgeo.RegularSurface(mfile) y = xtgeo.RegularSurface(mfile) si = x.similarity_index(y) tsetup.assert_equal(si, 0.0) y.values = y.values * 2 si = x.similarity_index(y) tsetup.assert_equal(si, 1.0)