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)
