def test_Interp_1dsignal(par): """Dot-test and forward for Interp operator for 1d signal """ np.random.seed(1) x = np.random.normal(0, 1, par['nx']) + \ par['imag'] * np.random.normal(0, 1, par['nx']) Nsub = int(np.round(par['nx'] * perc_subsampling)) iava = np.sort(np.random.permutation(np.arange(par['nx']))[:Nsub]) # fixed indeces Iop, _ = Interp(par['nx'], iava, kind=par['kind'], dtype=par['dtype']) assert dottest(Iop, Nsub, par['nx'], complexflag=0 if par['imag'] == 0 else 3) # decimal indeces Idecop, _ = Interp(par['nx'], iava + 0.3, kind=par['kind'], dtype=par['dtype']) assert dottest(Iop, Nsub, par['nx'], complexflag=0 if par['imag'] == 0 else 3) # repeated indeces with pytest.raises(ValueError): iava_rep = iava.copy() iava_rep[-2] = 0 iava_rep[-1] = 0 _, _ = Interp(par['nx'], iava_rep + 0.3, kind=par['kind'], dtype=par['dtype']) # forward y = Iop * x ydec = Idecop * x assert_array_almost_equal(y, x[iava]) if par['kind'] == 'nearest': assert_array_almost_equal(ydec, x[iava])
def test_Restriction_2dsignal(par): """Dot-test, forward and adjoint for Restriction operator for 2d signal """ np.random.seed(10) x = np.ones((par['nx'], par['nt'])) + \ par['imag'] * np.ones((par['nx'], par['nt'])) # 1st direction Nsub = int(np.round(par['nx'] * perc_subsampling)) iava = np.sort(np.random.permutation(np.arange(par['nx']))[:Nsub]) Rop = Restriction(par['nx']*par['nt'], iava, dims=(par['nx'], par['nt']), dir=0, inplace=par['dtype'], dtype=par['dtype']) assert dottest(Rop, Nsub*par['nt'], par['nx']*par['nt'], complexflag=0 if par['imag'] == 0 else 3) y = (Rop * x.ravel()).reshape(Nsub, par['nt']) x1 = (Rop.H * y.ravel()).reshape(par['nx'], par['nt']) y1_fromflat = Rop.mask(x.ravel()) y1 = Rop.mask(x) assert_array_almost_equal(y, y1_fromflat.reshape(par['nx'], par['nt'])[iava]) assert_array_almost_equal(y, y1[iava]) assert_array_almost_equal(x[iava], x1[iava]) # 2nd direction Nsub = int(np.round(par['nt'] * perc_subsampling)) iava = np.sort(np.random.permutation(np.arange(par['nt']))[:Nsub]) Rop = Restriction(par['nx'] * par['nt'], iava, dims=(par['nx'], par['nt']), dir=1, inplace=par['dtype'], dtype=par['dtype']) assert dottest(Rop, par['nx'] * Nsub, par['nx'] * par['nt'], complexflag=0 if par['imag'] == 0 else 3) y = (Rop * x.ravel()).reshape(par['nx'], Nsub) x1 = (Rop.H * y.ravel()).reshape(par['nx'], par['nt']) y1_fromflat = Rop.mask(x.ravel()) y1 = Rop.mask(x) assert_array_almost_equal(y, y1_fromflat[:, iava]) assert_array_almost_equal(y, y1[:, iava]) assert_array_almost_equal(x[:, iava], x1[:, iava])
def test_ChirpRadon3D(par): """Dot-test, forward, analytical inverse and sparse inverse for ChirpRadon3D operator """ parmod = { "ot": 0, "dt": 0.004, "nt": par["nt"], "ox": par["nhx"] * 10 / 2, "dx": 10, "nx": par["nhx"], "oy": par["nhy"] * 10 / 2, "dy": 10, "ny": par["nhy"], "f0": 40, } theta = [ 20, ] phi = [ 0, ] t0 = [ 0.1, ] amp = [ 1.0, ] # Create axis t, t2, hx, hy = makeaxis(parmod) # Create wavelet wav, _, wav_c = ricker(t[:41], f0=parmod["f0"]) # Generate model _, x = linear3d(hy, hx, t, 1500.0, t0, theta, phi, amp, wav) Rop = ChirpRadon3D( t, hy, hx, (par["pymax"], par["pxmax"]), engine=par["engine"], dtype="float64", **dict(flags=("FFTW_ESTIMATE",), threads=2) ) assert dottest( Rop, par["nhy"] * par["nhx"] * par["nt"], par["nhy"] * par["nhx"] * par["nt"] ) y = Rop * x.ravel() xinvana = Rop.inverse(y) assert_array_almost_equal(x.ravel(), xinvana, decimal=3) xinv, _, _ = FISTA(Rop, y, 30, eps=1e0, returninfo=True) assert_array_almost_equal(x.ravel(), xinv, decimal=3)
def test_PhaseShift_2dsignal(par): """Dot-test for PhaseShift of 2d signal """ vel = 1500. zprop = 200 freq = np.fft.rfftfreq(par['nt'], 1.) kx = np.fft.fftshift(np.fft.fftfreq(par['nx'], 1.)) Pop = PhaseShift(vel, zprop, par['nt'], freq, kx, dtype=par['dtype']) assert dottest(Pop, par['nt'] * par['nx'], par['nt'] * par['nx'])
def test_LinearRegression(par): """Dot-test and inversion for LinearRegression operator """ t = np.arange(par['ny']) LRop = LinearRegression(t, dtype=par['dtype']) assert dottest(LRop, par['ny'], 2) x = np.array([1., 2.]) xlsqr = lsqr(LRop, LRop*x, damp=1e-10, iter_lim=300, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=4)
def test_Pad2d(par): """Dot-test and adjoint for Pad operator on 2d signal""" Pop = Pad(dims=(par["ny"], par["nx"]), pad=par["pad"], dtype=par["dtype"]) assert dottest(Pop, Pop.shape[0], Pop.shape[1]) x = (np.arange(par["ny"] * par["nx"], dtype=par["dtype"]) + 1.0).reshape( par["ny"], par["nx"]) y = Pop * x.ravel() xadj = Pop.H * y assert_array_equal(x.ravel(), xadj)
def test_Sum3D(par): """Dot-test, forward and adjoint for Sum operator on 3d signal """ for dir in [0, 1, 2]: dim_d = [par['ny'], par['nx'], par['nx']] dim_d.pop(dir) Sop = Sum(dims=(par['ny'], par['nx'], par['nx']), dir=dir, dtype=par['dtype']) assert dottest(Sop, np.prod(dim_d), par['ny'] * par['nx'] * par['nx'])
def test_Pad1d(par): """Dot-test and adjoint for Pad operator on 1d signal """ Pop = Pad(dims=par['ny'], pad=par['pad'][0], dtype=par['dtype']) assert dottest(Pop, Pop.shape[0], Pop.shape[1]) x = np.arange(par['ny'], dtype=par['dtype']) + 1. y = Pop * x xinv = Pop.H * y assert_array_equal(x, xinv)
def test_FFT_2dsignal(par): """Dot-test and inversion for fft operator for 2d signal (fft on single dimension) """ dt = 0.005 nt, nx = par['nt'], par['nx'] t = np.arange(nt) * dt f0 = 10 d = np.outer(np.sin(2 * np.pi * f0 * t), np.arange(nx) + 1) # 1st dimension FFTop = FFT(dims=(nt, nx), dir=0, nfft=par['nfft'], sampling=dt) assert dottest(FFTop, par['nfft'] * par['nx'], par['nt'] * par['nx'], complexflag=2) D = FFTop * d.flatten() dadj = FFTop.H * D # adjoint is same as inverse for fft dinv = lsqr(FFTop, D, damp=1e-10, iter_lim=10, show=0)[0] dadj = np.real(dadj.reshape(par['nt'], par['nx'])) dinv = np.real(dinv.reshape(par['nt'], par['nx'])) assert_array_almost_equal(d, dadj, decimal=8) assert_array_almost_equal(d, dinv, decimal=8) # 2nd dimension FFTop = FFT(dims=(nt, nx), dir=1, nfft=par['nfft'], sampling=dt) assert dottest(FFTop, par['nt'] * par['nfft'], par['nt'] * par['nx'], complexflag=2) D = FFTop * d.flatten() dadj = FFTop.H * D # adjoint is inverse for fft dinv = lsqr(FFTop, D, damp=1e-10, iter_lim=10, show=0)[0] dadj = np.real(dadj.reshape(par['nt'], par['nx'])) dinv = np.real(dinv.reshape(par['nt'], par['nx'])) assert_array_almost_equal(d, dadj, decimal=8) assert_array_almost_equal(d, dinv, decimal=8)
def test_predict(par): """Dot-test for _predict operator """ def _predict_reshape(traces, nt, nx, dt, dx, slopes, repeat=0, backward=False, adj=False): return _predict(traces.reshape(nx, nt), dt, dx, slopes, repeat=repeat, backward=backward, adj=adj) for repeat in (0, 1, 2): slope = \ np.random.normal(0, .1, (2 ** (repeat + 1) * par['nx'], par['nt'])) for backward in (False, True): Fop = FunctionOperator( lambda x: _predict_reshape(x, par['nt'], par['nx'], par['dt'], par['dx'], slope, backward=backward), lambda x: _predict_reshape(x, par['nt'], par['nx'], par['dt'], par['dx'], slope, backward=backward, adj=True), par['nt'] * par['nx'], par['nt'] * par['nx']) dottest(Fop, par['nt'] * par['nx'], par['nt'] * par['nx'])
def test_PrestackLinearModelling(par): """Dot-test and comparison of dense vs lop implementation for PrestackLinearModelling """ # Dense operator PPop_dense = PrestackLinearModelling(wav, theta, vsvp=par['vsvp'], nt0=nt0, linearization=par['linearization'], explicit=True) assert dottest(PPop_dense, nt0 * ntheta, nt0 * 3) # Linear operator PPop = PrestackLinearModelling(wav, theta, vsvp=par['vsvp'], nt0=nt0, linearization=par['linearization']) assert dottest(PPop, nt0 * ntheta, nt0 * 3) # Compare data d = PPop * m.flatten() d = d.reshape(nt0, ntheta) d_dense = PPop_dense * m.T.flatten() d_dense = d_dense.reshape(ntheta, nt0).T assert_array_almost_equal(d, d_dense, decimal=4)
def test_Flip1D(par): """Dot-test, forward and adjoint for Flip operator on 1d signal""" np.random.seed(10) x = np.arange(par["ny"]) + par["imag"] * np.arange(par["ny"]) Fop = Flip(par["ny"], dtype=par["dtype"]) assert dottest(Fop, par["ny"], par["ny"]) y = Fop * x xadj = Fop.H * y assert_array_equal(x, xadj)
def test_AVOLinearModelling(par): """Dot-test and inversion for AVOLinearModelling """ AVOop = AVOLinearModelling(theta, vsvp=par['vsvp'], nt0=nt0, linearization=par['linearization']) assert dottest(AVOop, ntheta * nt0, 3 * nt0) minv = lsqr(AVOop, AVOop * m, damp=1e-20, iter_lim=1000, show=0)[0] assert_array_almost_equal(m, minv, decimal=3)
def test_Radon3D(par): """Dot-test, forward and adjoint consistency check (for onthefly parameter), and sparse inverse for Radon3D operator """ if par['engine'] == 'numpy' or \ multiprocessing.cpu_count() >= 4: # avoid timeout in travis for numba dt, dhy, dhx = 0.005, 1, 1 t = np.arange(par['nt']) * dt hy = np.arange(par['nhy']) * dhy hx = np.arange(par['nhx']) * dhx py = np.linspace(0, par['pymax'], par['npy']) px = np.linspace(0, par['pxmax'], par['npx']) x = np.zeros((par['npy'], par['npx'], par['nt'])) x[3, 2, par['nt'] // 2] = 1 Rop = Radon3D(t, hy, hx, py, px, centeredh=par['centeredh'], interp=par['interp'], kind=par['kind'], onthefly=False, engine=par['engine'], dtype='float64') R1op = Radon3D(t, hy, hx, py, px, centeredh=par['centeredh'], interp=par['interp'], kind=par['kind'], onthefly=True, engine=par['engine'], dtype='float64') assert dottest(Rop, par['nhy'] * par['nhx'] * par['nt'], par['npy'] * par['npx'] * par['nt'], tol=1e-3) y = Rop * x.flatten() y1 = R1op * x.flatten() assert_array_almost_equal(y, y1, decimal=4) xadj = Rop.H * y xadj1 = R1op.H * y assert_array_almost_equal(xadj, xadj1, decimal=4) if Rop.engine == 'numba': # as numpy is too slow here... xinv, _, _ = FISTA(Rop, y, 200, eps=3e0, returninfo=True) assert_array_almost_equal(x.flatten(), xinv, decimal=1)
def test_Roll1D(par): """Dot-test, forward and adjoint for Roll operator on 1d signal""" np.random.seed(10) x = np.arange(par["ny"]) + par["imag"] * np.arange(par["ny"]) Rop = Roll(par["ny"], shift=2, dtype=par["dtype"]) assert dottest(Rop, par["ny"], par["ny"]) y = Rop * x xadj = Rop.H * y assert_array_almost_equal(x, xadj, decimal=3)
def test_CausalIntegration1d(par): """Dot-test and inversion for CausalIntegration operator for 1d signals """ t = np.arange(par['nt']) * par['dt'] x = t + par['imag'] * t Cop = CausalIntegration(par['nt'], sampling=par['dt'], halfcurrent=False, dtype=par['dtype']) assert dottest(Cop, par['nt'], par['nt'], complexflag=0 if par['imag'] == 0 else 3) Cop = CausalIntegration(par['nt'], sampling=par['dt'], halfcurrent=True, dtype=par['dtype']) assert dottest(Cop, par['nt'], par['nt'], complexflag=0 if par['imag'] == 0 else 3) # numerical integration y = Cop * x # analytical integration yana = t ** 2 / 2. - t[0] ** 2 / 2.\ + par['imag'] * (t ** 2 / 2. - t[0] ** 2 / 2.) + y[0] assert_array_almost_equal(y, yana, decimal=4) # numerical derivative Dop = FirstDerivative(par['nt'], sampling=par['dt'], dtype=par['dtype']) xder = Dop * y.flatten() # derivative by inversion xinv = Cop / y assert_array_almost_equal(x[:-1], xder[:-1], decimal=4) assert_array_almost_equal(x, xinv, decimal=4)
def test_Smoothing1D(par): """Dot-test and inversion for smoothing""" # 1d kernel on 1d signal D1op = Smoothing1D(nsmooth=5, dims=par["nx"], dtype="float64") assert dottest(D1op, par["nx"], par["nx"]) x = np.random.normal(0, 1, par["nx"]) y = D1op * x xlsqr = lsqr(D1op, y, damp=1e-10, iter_lim=100, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=3) # 1d kernel on 2d signal D1op = Smoothing1D(nsmooth=5, dims=(par["ny"], par["nx"]), dir=par["dir"], dtype="float64") assert dottest(D1op, par["ny"] * par["nx"], par["ny"] * par["nx"]) x = np.random.normal(0, 1, (par["ny"], par["nx"])).ravel() y = D1op * x xlsqr = lsqr(D1op, y, damp=1e-10, iter_lim=100, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=3) # 1d kernel on 3d signal D1op = Smoothing1D( nsmooth=5, dims=(par["nz"], par["ny"], par["nx"]), dir=par["dir"], dtype="float64", ) assert dottest( D1op, par["nz"] * par["ny"] * par["nx"], par["nz"] * par["ny"] * par["nx"], tol=1e-3, ) x = np.random.normal(0, 1, (par["nz"], par["ny"], par["nx"])).ravel() y = D1op * x xlsqr = lsqr(D1op, y, damp=1e-10, iter_lim=100, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=3)
def test_Diagonal(par): """Dot-test and inversion for Diagonal operator """ d = np.arange(par['nx']) + 1. Dop = Diagonal(d, dtype=par['dtype']) assert dottest(Dop, par['nx'], par['nx'], complexflag=0 if par['imag'] == 0 else 3) x = np.ones(par['nx']) + par['imag']*np.ones(par['nx']) xlsqr = lsqr(Dop, Dop * x, damp=1e-20, iter_lim=300, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=4)
def test_Zero(par): """Dot-test, forward and adjoint for Zero operator """ Zop = Zero(par['ny'], par['nx'], dtype=par['dtype']) assert dottest(Zop, par['ny'], par['nx']) x = np.ones(par['nx']) + par['imag']*np.ones(par['nx']) y = Zop * x x1 = Zop.H*y assert_array_almost_equal(y, np.zeros(par['ny'])) assert_array_almost_equal(x1, np.zeros(par['nx']))
def test_SecondDirectionalDerivative(par): """Dot-test for test_SecondDirectionalDerivative operator """ # 2d Fdop = \ SecondDirectionalDerivative((par['ny'], par['nx']), v=np.sqrt(2.) / 2. * np.ones(2), sampling=(par['dy'], par['dx']), edge=par['edge'], dtype='float32') assert dottest(Fdop, par['ny'] * par['nx'], par['ny'] * par['nx'], tol=1e-3) # 3d Fdop = \ SecondDirectionalDerivative((par['nz'], par['ny'], par['nx']), v=np.ones(3) / np.sqrt(3), sampling=(par['dz'], par['dy'], par['dx']), edge=par['edge'], dtype='float32') assert dottest(Fdop, par['nz'] * par['ny'] * par['nx'], par['nz'] * par['ny'] * par['nx'], tol=1e-3)
def test_Zero(par): """Dot-test, forward and adjoint for Zero operator""" np.random.seed(10) Zop = Zero(par["ny"], par["nx"], dtype=par["dtype"]) assert dottest(Zop, par["ny"], par["nx"]) x = np.ones(par["nx"]) + par["imag"] * np.ones(par["nx"]) y = Zop * x x1 = Zop.H * y assert_array_almost_equal(y, np.zeros(par["ny"])) assert_array_almost_equal(x1, np.zeros(par["nx"]))
def test_MatrixMult(par): """Dot-test and inversion for test_MatrixMult operator """ np.random.seed(10) G = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32') + \ par['imag']*np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32') Gop = MatrixMult(G, dtype=par['dtype']) assert dottest(Gop, par['ny'], par['nx'], complexflag=0 if par['imag'] == 0 else 3) x = np.ones(par['nx']) + par['imag']*np.ones(par['nx']) xlsqr = lsqr(Gop, Gop*x, damp=1e-20, iter_lim=300, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=4)
def test_Bilinear_3dsignal(par): """Dot-test and forward for Interp operator for 3d signal """ x = np.random.normal(0, 1, (par['ny'], par['nx'], par['nt'])) + \ par['imag'] * np.random.normal(0, 1, (par['ny'], par['nx'], par['nt'])) # fixed indeces iava = np.vstack((np.arange(0, 10), np.arange(0, 10))) Iop = Bilinear(iava, dims=(par['ny'], par['nx'], par['nt']), dtype=par['dtype']) assert dottest(Iop, 10 * par['nt'], par['ny'] * par['nx'] * par['nt'], complexflag=0 if par['imag'] == 0 else 3) # decimal indeces Nsub = int(np.round(par['ny'] * par['nt'] * perc_subsampling)) iavadec = np.vstack( (np.random.uniform(0, par['ny'] - 1, Nsub), np.random.uniform(0, par['nx'] - 1, Nsub))) Idecop = Bilinear(iavadec, dims=(par['ny'], par['nx'], par['nt']), dtype=par['dtype']) assert dottest(Idecop, Nsub * par['nt'], par['ny'] * par['nx'] * par['nt'], complexflag=0 if par['imag'] == 0 else 3) # repeated indeces with pytest.raises(ValueError): iava_rep = iava.copy() iava_rep[-2] = [0, 0] iava_rep[-1] = [0, 0] _, _ = Bilinear(iava_rep, dims=(par['ny'], par['nx'], par['nt']), dtype=par['dtype']) y = (Iop * x.ravel()) assert_array_almost_equal(y, x[iava[0], iava[1]].ravel())
def test_Convolve2D(par): """Dot-test and inversion for Convolve2D operator""" # 2D on 2D if par["dir"] == 2: Cop = Convolve2D( par["ny"] * par["nx"], h=h2, offset=par["offset"], dims=(par["ny"], par["nx"]), dtype="float64", ) assert dottest(Cop, par["ny"] * par["nx"], par["ny"] * par["nx"]) x = np.zeros((par["ny"], par["nx"])) x[int(par["ny"] / 2 - 3):int(par["ny"] / 2 + 3), int(par["nx"] / 2 - 3):int(par["nx"] / 2 + 3), ] = 1.0 x = x.ravel() xlsqr = lsqr(Cop, Cop * x, damp=1e-20, iter_lim=200, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=1) # 2D on 3D Cop = Convolve2D( par["nz"] * par["ny"] * par["nx"], h=h2, offset=par["offset"], dims=[par["nz"], par["ny"], par["nx"]], nodir=par["dir"], dtype="float64", ) assert dottest(Cop, par["nz"] * par["ny"] * par["nx"], par["nz"] * par["ny"] * par["nx"]) x = np.zeros((par["nz"], par["ny"], par["nx"])) x[int(par["nz"] / 2 - 3):int(par["nz"] / 2 + 3), int(par["ny"] / 2 - 3):int(par["ny"] / 2 + 3), int(par["nx"] / 2 - 3):int(par["nx"] / 2 + 3), ] = 1.0 x = x.ravel() xlsqr = lsqr(Cop, Cop * x, damp=1e-20, iter_lim=200, show=0)[0] # due to ringing in solution we cannot use assert_array_almost_equal assert np.linalg.norm(xlsqr - x) / np.linalg.norm(xlsqr) < 2e-1
def test_FunctionOperator(par): """Dot-test and inversion for FunctionOperator operator.""" print(par) np.random.seed(10) G = (np.random.normal(0, 1, (par["nr"], par["nc"])) + np.random.normal(0, 1, (par["nr"], par["nc"])) * par["imag"]).astype( par["dtype"]) def forward_f(x): return G @ x def adjoint_f(y): return np.conj(G.T) @ y if par["nr"] == par["nc"]: Fop = FunctionOperator(forward_f, adjoint_f, par["nr"], dtype=par["dtype"]) else: Fop = FunctionOperator(forward_f, adjoint_f, par["nr"], par["nc"], dtype=par["dtype"]) assert dottest( Fop, par["nr"], par["nc"], complexflag=0 if par["imag"] == 0 else 3, tol=par["tol"], ) x = (np.ones(par["nc"]) + np.ones(par["nc"]) * par["imag"]).astype( par["dtype"]) y = (np.ones(par["nr"]) + np.ones(par["nr"]) * par["imag"]).astype( par["dtype"]) F_x = Fop @ x FH_y = Fop.H @ y G_x = np.asarray(G @ x) GH_y = np.asarray(np.conj(G.T) @ y) assert_array_equal(F_x, G_x) assert_array_equal(FH_y, GH_y) # Only test inversion for square or overdetermined systems if par["nc"] <= par["nr"]: xlsqr = lsqr(Fop, F_x, damp=0, iter_lim=100, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=4)
def test_ChirpRadon3D(par): """Dot-test, forward, analytical inverse and sparse inverse for ChirpRadon3D operator """ parmod = { 'ot': 0, 'dt': 0.004, 'nt': par['nt'], 'ox': par['nhx'] * 10 / 2, 'dx': 10, 'nx': par['nhx'], 'oy': par['nhy'] * 10 / 2, 'dy': 10, 'ny': par['nhy'], 'f0': 40 } theta = [ 20, ] phi = [ 0, ] t0 = [ 0.1, ] amp = [ 1., ] # Create axis t, t2, hx, hy = makeaxis(parmod) # Create wavelet wav, _, wav_c = ricker(t[:41], f0=parmod['f0']) # Generate model _, x = linear3d(hy, hx, t, 1500., t0, theta, phi, amp, wav) Rop = ChirpRadon3D(t, hy, hx, (par['pymax'], par['pxmax']), engine=par['engine'], dtype='float64', **dict(flags=('FFTW_ESTIMATE', ), threads=2)) assert dottest(Rop, par['nhy'] * par['nhx'] * par['nt'], par['nhy'] * par['nhx'] * par['nt']) y = Rop * x.ravel() xinvana = Rop.inverse(y) assert_array_almost_equal(x.ravel(), xinvana, decimal=3) xinv, _, _ = FISTA(Rop, y, 30, eps=1e0, returninfo=True) assert_array_almost_equal(x.ravel(), xinv, decimal=3)
def test_MatrixMult_diagonal(par): """Dot-test and inversion for test_MatrixMult operator repeated along another dimension """ np.random.seed(10) G = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32') + \ par['imag'] * np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32') Gop = MatrixMult(G, dims=5, dtype=par['dtype']) assert dottest(Gop, par['ny']*5, par['nx']*5, complexflag=0 if par['imag'] == 1 else 3) x = (np.ones((par['nx'], 5)) + par['imag'] * np.ones((par['nx'], 5))).flatten() xlsqr = lsqr(Gop, Gop*x, damp=1e-20, iter_lim=300, show=0)[0] assert_array_almost_equal(x, xlsqr, decimal=4)
def test_PrestackWaveletModelling(par): """Dot-test and inversion for PrestackWaveletModelling """ # Operators Wavestop = PrestackWaveletModelling(m, theta, nwav=ntwav, wavc=wavc, vsvp=par['vsvp'], linearization=par['linearization']) assert dottest(Wavestop, nt0 * ntheta, ntwav) Wavestop_phase = PrestackWaveletModelling(m, theta, nwav=ntwav, wavc=wavc, vsvp=par['vsvp'], linearization=par['linearization']) assert dottest(Wavestop_phase, nt0 * ntheta, ntwav) # Create data d = (Wavestop * wav).reshape(ntheta, nt0).T d_phase = (Wavestop_phase * wav_phase).reshape(ntheta, nt0).T # Estimate wavelet wav_est = Wavestop / d.T.flatten() wav_phase_est = Wavestop_phase / d_phase.T.flatten() assert_array_almost_equal(wav, wav_est, decimal=3) assert_array_almost_equal(wav_phase, wav_phase_est, decimal=3)
def test_PoststackLinearModelling2d(par): """Dot-test and inversion for PoststackLinearModelling in 2d""" # Dense PPop_dense = PoststackLinearModelling(wav, nt0=nz, spatdims=nx, explicit=True) assert dottest(PPop_dense, nz * nx, nz * nx, tol=1e-4) # Linear operator PPop = PoststackLinearModelling(wav, nt0=nz, spatdims=nx, explicit=False) assert dottest(PPop, nz * nx, nz * nx, tol=1e-4) # Compare data d = (PPop * m2d.ravel()).reshape(nz, nx) d_dense = (PPop_dense * m2d.ravel()).reshape(nz, nx) assert_array_almost_equal(d, d_dense, decimal=4) # Inversion for explicit in [True, False]: if explicit and not par["simultaneous"] and par["epsR"] is None: dict_inv = {} elif explicit and not par["simultaneous"] and par["epsR"] is not None: dict_inv = dict(damp=0 if par["epsI"] is None else par["epsI"], iter_lim=10) else: dict_inv = dict(damp=0 if par["epsI"] is None else par["epsI"], iter_lim=10) minv2d = PoststackInversion(d, wav, m0=mback2d, explicit=explicit, epsI=par["epsI"], epsR=par["epsR"], epsRL1=par["epsRL1"], simultaneous=par["simultaneous"], **dict_inv)[0] assert np.linalg.norm(m2d - minv2d) / np.linalg.norm(m2d) < 1e-1
def test_Gradient(par): """Dot-test for Gradient operator """ # 2d Gop = Gradient((par['ny'], par['nx']), sampling=(par['dy'], par['dx']), edge=par['edge'], dtype='float32') assert dottest(Gop, 2 * par['ny'] * par['nx'], par['ny'] * par['nx'], tol=1e-3) # 3d Gop = Gradient((par['nz'], par['ny'], par['nx']), sampling=(par['dz'], par['dy'], par['dx']), edge=par['edge'], dtype='float32') assert dottest(Gop, 3 * par['nz'] * par['ny'] * par['nx'], par['nz'] * par['ny'] * par['nx'], tol=1e-3)