Exemple #1
0
def test_traveltime_table():
    """Compare analytical and eikonal traveltimes in homogenous medium
    """
    # 2d
    trav_ana, trav_srcs_ana, trav_recs_ana =\
        _traveltime_table(z, x, s2d, r2d, v0, mode='analytic')

    trav_eik, trav_srcs_eik, trav_recs_eik = \
        _traveltime_table(z, x, s2d, r2d, v0*np.ones((PAR['nx'], PAR['nz'])),
                          mode='eikonal')

    assert_array_almost_equal(trav_srcs_ana, trav_srcs_eik, decimal=2)
    assert_array_almost_equal(trav_recs_ana, trav_recs_ana, decimal=2)
    assert_array_almost_equal(trav_ana, trav_eik, decimal=2)

    # 3d
    trav_ana, trav_srcs_ana, trav_recs_ana = \
        _traveltime_table(z, x, s3d, r3d, v0, y=y, mode='analytic')

    trav_eik, trav_srcs_eik, trav_recs_eik = \
        _traveltime_table(z, x, s3d, r3d,
                          v0 * np.ones((PAR['ny'], PAR['nx'], PAR['nz'])),
                          y=y, mode='eikonal')

    assert_array_almost_equal(trav_srcs_ana, trav_srcs_eik, decimal=2)
    assert_array_almost_equal(trav_recs_ana, trav_recs_eik, decimal=2)
    assert_array_almost_equal(trav_ana, trav_eik, decimal=2)
Exemple #2
0
def test_demigration2d(par):
    """Dot-test for Demigration operator"""
    vel = v0 * np.ones((PAR["nx"], PAR["nz"]))

    if par["mode"] == "byot":
        trav, _, _ = _traveltime_table(z, x, s2d, r2d, v0, mode="analytic")
    else:
        trav = None

    if skfmm_enabled or par["mode"] != "eikonal":
        Dop = Demigration(
            z,
            x,
            t,
            s2d,
            r2d,
            vel if par["mode"] == "eikonal" else v0,
            wav,
            wavc,
            y=None,
            trav=trav,
            mode=par["mode"],
        )
        assert dottest(Dop, PAR["nsx"] * PAR["nrx"] * PAR["nt"],
                       PAR["nz"] * PAR["nx"])
Exemple #3
0
def test_traveltime_ana():
    """Check analytical traveltimes in homogenous medium for horizontal and
    vertical paths
    """
    src = np.array([100, 0])[:, np.newaxis]

    _, trav_srcs_ana, trav_recs_ana = \
        _traveltime_table(np.arange(0, 200, 1), np.arange(0, 200, 1),
                          src, src, v0, mode='analytic')
    assert trav_srcs_ana[0, 0] == 100 / v0
    assert trav_recs_ana[0, 0] == 100 / v0
def test_demigration2d(par):
    """Dot-test for Demigration operator
    """
    vel = v0 * np.ones((PAR['nx'], PAR['nz']))

    if par['mode'] == 'byot':
        trav, _, _ = \
            _traveltime_table(z, x, s2d, r2d, v0, mode='analytic')
    else:
        trav = None

    Dop = Demigration(z, x, t, s2d, r2d,
                      vel if par['mode'] == 'eikonal' else v0, wav, wavc,
                      y=None, trav=trav, mode=par['mode'])
    assert dottest(Dop, PAR['nsx']*PAR['nrx']*PAR['nt'], PAR['nz']*PAR['nx'])
Exemple #5
0
def test_traveltime_table():
    """Compare analytical and eikonal traveltimes in homogenous medium"""
    if skfmm_enabled:
        # 2d
        trav_ana, trav_srcs_ana, trav_recs_ana = _traveltime_table(
            z, x, s2d, r2d, v0, mode="analytic")

        trav_eik, trav_srcs_eik, trav_recs_eik = _traveltime_table(
            z,
            x,
            s2d,
            r2d,
            v0 * np.ones((PAR["nx"], PAR["nz"])),
            mode="eikonal")

        assert_array_almost_equal(trav_srcs_ana, trav_srcs_eik, decimal=2)
        assert_array_almost_equal(trav_recs_ana, trav_recs_ana, decimal=2)
        assert_array_almost_equal(trav_ana, trav_eik, decimal=2)

        # 3d
        trav_ana, trav_srcs_ana, trav_recs_ana = _traveltime_table(
            z, x, s3d, r3d, v0, y=y, mode="analytic")

        trav_eik, trav_srcs_eik, trav_recs_eik = _traveltime_table(
            z,
            x,
            s3d,
            r3d,
            v0 * np.ones((PAR["ny"], PAR["nx"], PAR["nz"])),
            y=y,
            mode="eikonal",
        )

        assert_array_almost_equal(trav_srcs_ana, trav_srcs_eik, decimal=2)
        assert_array_almost_equal(trav_recs_ana, trav_recs_eik, decimal=2)
        assert_array_almost_equal(trav_ana, trav_eik, decimal=2)
Exemple #6
0
vel[:, 40:50] = 1800
vel[:, 50:80] = 2000
vel[:, 80:] = 2500

# Smooth velocity
nsmooth=20
velback = filtfilt(np.ones(nsmooth)/float(nsmooth), 1, vel, axis=0)
for _ in range(5):
    velback = filtfilt(np.ones(nsmooth)/float(nsmooth), 1, velback, axis=1)
    
#%% Calculate the travel time using eikonal

nt = 401
dt = 0.004
t = np.arange(nt)*dt
trav, trav_srcs, trav_recs = _traveltime_table(z, x, sources, recs, velback, mode='eikonal')

itrav = (np.floor(trav/dt)).astype(np.int32)
travd = (trav/dt - itrav)
itrav = itrav.reshape(nx, nz, ns*nr)
travd = travd.reshape(nx, nz, ns*nr)

#%% Modelling

Sop = Spread(dims=(nx, nz), dimsd=(ns*nr, nt), table=itrav, dtable=travd, engine='numba')
dottest(Sop, ns*nr*nt, nx*nz, verb=True)

wav, wavt, wavc = ricker(t[:41], f0=20)
Cop = Convolve1D(ns*nr*nt, h=wav, offset=wavc, dims=(ns*nr, nt), dir=1)
Dop = FirstDerivative(nx*nz, dims=(nx, nz), dir=1)
LSMop = Cop*Sop*Dop
plt.title('Velocity')
plt.xlim(x[0], x[-1])

plt.figure(figsize=(10,5))
im = plt.imshow(refl.T, cmap='gray', extent = (x[0], x[-1], z[-1], z[0]))
plt.scatter(recs[0],  recs[1], marker='v', s=150, c='b', edgecolors='k')
plt.scatter(sources[0], sources[1], marker='*', s=150, c='r', edgecolors='k')
plt.colorbar(im)
plt.axis('tight')
plt.xlabel('x [m]'),plt.ylabel('y [m]')
plt.title('Reflectivity')
plt.xlim(x[0], x[-1]);

#%% Computes travel times for homogenous medium

trav, trav_srcs, trav_recs = _traveltime_table(z, x, sources, recs, v0, mode='analytic')

fig, axs = plt.subplots(1, 3, figsize=(14, 3))
im = axs[0].imshow(trav_srcs[:, ns//2].reshape((nx, nz)).T, cmap='rainbow', 
                   extent = (x[0], x[-1], z[-1], z[0]))
axs[0].scatter(sources[0, ns//2], sources[1, ns//2], marker='*', s=150, c='r', edgecolors='k')
axs[0].axis('tight')
axs[0].set_xlabel('x [m]')
axs[0].set_ylabel('y [m]')
axs[0].set_title('Source traveltime')
axs[0].set_ylim(z[-1], z[0])
plt.colorbar(im, ax=axs[0])
im = axs[1].imshow(trav_recs[:, nr//4].reshape((nx, nz)).T, cmap='rainbow', 
                   extent = (x[0], x[-1], z[-1], z[0]))
axs[1].scatter(recs[0, nr//4], recs[1, nr//4], marker='v', s=150, c='b', edgecolors='k')
axs[1].axis('tight')