def born(model, src_coords, rcv_coords, wavelet, space_order=8,
save=False, q=None, free_surface=False, isic=False, ws=None):
"""
Low level propagator, to be used through `interface.py`
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
# Setting adjoint wavefield
u = wavefield(model, space_order, save=save, nt=wavelet.shape[0])
ul = wavefield(model, space_order, name="l")
# Extended source
q = q or wf_as_src(u, w=0)
q = extented_src(model, ws, wavelet, q=q)
# Set up PDE expression and rearrange
pde, fsu = wave_kernel(model, u, fs=free_surface, q=q)
pdel, fsul = wave_kernel(model, ul, q=lin_src(model, u, isic=isic), fs=free_surface)
# Setup source and receiver
geom_expr, _, _ = src_rec(model, u, src_coords=src_coords, wavelet=wavelet)
geom_exprl, _, rcvl = src_rec(model, ul, rec_coords=rcv_coords, nt=wavelet.shape[0])
# Create operator and run
subs = model.spacing_map
op = Operator(pde + geom_expr + pdel + geom_exprl + fsu + fsul,
subs=subs, name="born"+name(model))
op(**op_kwargs(model, fs=free_surface))
# Output
return rcvl.data, u
def forward(model,
src_coords,
rcv_coords,
wavelet,
dt=None,
space_order=8,
save=False,
q=0,
grad=False,
u=None,
return_op=False):
"""
Compute forward wavefield u = A(m)^{-1}*f and related quantities (u(xrcv))
"""
# Setting adjoint wavefield
u = u or wavefield(model, space_order, save=save, nt=wavelet.shape[0])
# Set up PDE expression and rearrange
pde = wave_kernel(model, u, q=q)
# Setup source and receiver
geom_expr, _, rcv = src_rec(model,
u,
src_coords=src_coords,
rec_coords=rcv_coords,
wavelet=wavelet)
# extras expressions
extras = []
if grad:
gradm = Function(name="gradm", grid=model.grid)
v = wavefield(model,
space_order,
save=True,
nt=wavelet.shape[0],
fw=False)
w = Constant(name="w")
extras = grad_expr(gradm, u, v, w=w)
# Create operator and run
subs = model.spacing_map
op = create_op(pde + geom_expr + extras,
subs=subs,
name="forward" + name(model))
if return_op:
return op
op()
# Output
if save:
return rcv.data, u
else:
return rcv.data, None
def born(model,
src_coords,
rcv_coords,
wavelet,
space_order=8,
save=False,
q=None,
isic=False,
ws=None,
t_sub=1):
"""
Low level propagator, to be used through `interface.py`
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
nt = wavelet.shape[0]
# Setting wavefield
u = wavefield(model, space_order, save=save, nt=nt, t_sub=t_sub)
ul = wavefield(model, space_order, name="l")
# Expression for saving wavefield if time subsampling is used
u_save, eq_save = wavefield_subsampled(model, u, nt, t_sub)
# Extended source
q = q or wf_as_src(u, w=0)
q = extented_src(model, ws, wavelet, q=q)
# Set up PDE expression and rearrange
pde, tmpu = wave_kernel(model, u, q=q)
pdel, tmpul = wave_kernel(model, ul, q=lin_src(model, u, isic=isic))
# Setup source and receiver
geom_expr, _, _ = src_rec(model, u, src_coords=src_coords, wavelet=wavelet)
geom_exprl, _, rcvl = src_rec(model,
ul,
rec_coords=rcv_coords,
nt=wavelet.shape[0])
# Create operator and run
subs = model.spacing_map
op = Operator(tmpu + tmpul + pde + geom_expr + geom_exprl + pdel + eq_save,
subs=subs,
name="born" + name(model),
opt=opt_op(model, no_ms=ws is not None))
summary = op()
# Output
return rcvl, (u_save if t_sub > 1 else u), summary
def adjoint_y_run(self,
y,
src_coords,
rcv_coords,
weight_fun_pars=None,
save=False):
v = wavefield(self.model,
self.space_order,
save=save,
nt=y.shape[0],
fw=False)
kwargs = wf_kwargs(v)
rcv = Receiver(name="rcv",
grid=self.model.grid,
ntime=y.shape[0],
coordinates=src_coords)
src = PointSource(name="src",
grid=self.model.grid,
ntime=y.shape[0],
coordinates=rcv_coords)
src.data[:, :] = y[:, :]
adj = self.op_adj_y(weight_fun_pars=weight_fun_pars, save=save)
i = Dimension(name="i", )
norm_v = Function(name="nvy2",
shape=(1, ),
dimensions=(i, ),
grid=self.model.grid)
adj(src=src, rcv=rcv, nvy2=norm_v, **kwargs)
return norm_v.data[0], rcv.data, v
def forward_run(self,
wav,
src_coords,
rcv_coords,
save=False,
q=0,
v=None,
w=0,
grad=False):
# Computing residual
u = wavefield(self.model, self.space_order, save=save, nt=wav.shape[0])
kwargs = wf_kwargs(u)
rcv = Receiver(name="rcv",
grid=self.model.grid,
ntime=wav.shape[0],
coordinates=rcv_coords)
src = PointSource(name="src",
grid=self.model.grid,
ntime=wav.shape[0],
coordinates=src_coords)
src.data[:] = wav[:]
fwd = self.op_fwd(save=save, q=q, grad=grad)
if grad:
w = Constant(name="w", value=w)
gradm = Function(name="gradm", grid=self.model.grid)
kwargs.update({as_tuple(v)[0].name: as_tuple(v)[0]})
kwargs.update({w.name: w, gradm.name: gradm})
fwd(rcv=rcv, src=src, **kwargs)
if grad:
return rcv.data, u, gradm
return rcv.data, u
def adjoint(model, y, src_coords, rcv_coords, space_order=8, q=0,
save=False, free_surface=False, ws=None):
"""
Low level propagator, to be used through `interface.py`
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
# Number of time steps
nt = as_tuple(q)[0].shape[0] if y is None else y.shape[0]
# Setting adjoint wavefield
v = wavefield(model, space_order, save=save, nt=nt, fw=False)
# Set up PDE expression and rearrange
pde, fs = wave_kernel(model, v, q=q, fw=False, fs=free_surface)
# Setup source and receiver
geom_expr, _, rcv = src_rec(model, v, src_coords=rcv_coords, nt=nt,
rec_coords=src_coords, wavelet=y, fw=False)
# Extended source
wsrc, ws_expr = extended_src_weights(model, ws, v)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + geom_expr + ws_expr + fs,
subs=subs, name="adjoint"+name(model))
op(**op_kwargs(model, fs=free_surface))
# Output
if wsrc:
return wsrc
return getattr(rcv, 'data', None), v
def gradient(model, residual, rcv_coords, u, return_op=False, space_order=8, t_sub=1,
w=None, free_surface=False, freq=None, dft_sub=None, isic=True):
"""
Low level propagator, to be used through `interface.py`
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
# Setting adjoint wavefieldgradient
v = wavefield(model, space_order, fw=False)
# Set up PDE expression and rearrange
pde, fs = wave_kernel(model, v, fw=False, fs=free_surface)
# Setup source and receiver
geom_expr, _, _ = src_rec(model, v, src_coords=rcv_coords,
wavelet=residual, fw=False)
# Setup gradient wrt m
gradm = Function(name="gradm", grid=model.grid)
g_expr = grad_expr(gradm, u, v, model, w=w, freq=freq, dft_sub=dft_sub, isic=isic)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + geom_expr + g_expr + fs,
subs=subs, name="gradient"+name(model))
if return_op:
return op, gradm, v
op(**op_kwargs(model, fs=free_surface))
# Output
return gradm.data
def gradient(model,
residual,
rcv_coords,
u,
return_op=False,
space_order=8,
w=None,
freq=None,
dft_sub=None,
isic=False):
"""
Low level propagator, to be used through `interface.py`
Compute the action of the adjoint Jacobian onto a residual J'* δ d.
"""
# Setting adjoint wavefieldgradient
v = wavefield(model, space_order, fw=False)
# Set up PDE expression and rearrange
pde = wave_kernel(model, v, fw=False)
# Setup source and receiver
geom_expr, _, _ = src_rec(model,
v,
src_coords=rcv_coords,
wavelet=residual,
fw=False)
# Setup gradient wrt m
gradm = Function(name="gradm", grid=model.grid)
g_expr = grad_expr(gradm,
u,
v,
model,
w=w,
freq=freq,
dft_sub=dft_sub,
isic=isic)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + geom_expr + g_expr,
subs=subs,
name="gradient" + name(model),
opt=opt_op(model))
try:
op.cfunction
except:
op = Operator(pde + geom_expr + g_expr,
subs=subs,
name="gradient" + name(model),
opt='advanced')
op.cfunction
if return_op:
return op, gradm, v
summary = op()
# Output
return gradm, summary
def forward(model,
src_coords,
rcv_coords,
wavelet,
space_order=8,
save=False,
q=None,
return_op=False,
freq_list=None,
dft_sub=None,
ws=None,
t_sub=1,
**kwargs):
"""
Low level propagator, to be used through `interface.py`
Compute forward wavefield u = A(m)^{-1}*f and related quantities (u(xrcv))
"""
# Number of time steps
nt = as_tuple(q)[0].shape[0] if wavelet is None else wavelet.shape[0]
# Setting forward wavefield
u = wavefield(model, space_order, save=save, nt=nt, t_sub=t_sub)
# Expression for saving wavefield if time subsampling is used
u_save, eq_save = wavefield_subsampled(model, u, nt, t_sub)
# Add extended source
q = q or wf_as_src(u, w=0)
q = extented_src(model, ws, wavelet, q=q)
# Set up PDE expression and rearrange
pde = wave_kernel(model, u, q=q)
# Setup source and receiver
geom_expr, _, rcv = src_rec(model,
u,
src_coords=src_coords,
nt=nt,
rec_coords=rcv_coords,
wavelet=wavelet)
# On-the-fly Fourier
dft, dft_modes = otf_dft(u, freq_list, model.critical_dt, factor=dft_sub)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + dft + geom_expr + eq_save,
subs=subs,
name="forward" + name(model),
opt=opt_op(model))
op.cfunction
if return_op:
return op, u, rcv
summary = op()
# Output
return rcv, dft_modes or (u_save if t_sub > 1 else u), summary
def adjoint(model,
y,
src_coords,
rcv_coords,
space_order=8,
q=0,
save=False,
ws=None,
norm_v=False,
w_fun=None):
"""
Low level propagator, to be used through `interface.py`
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
# Number of time steps
nt = as_tuple(q)[0].shape[0] if y is None else y.shape[0]
# Setting adjoint wavefield
v = wavefield(model, space_order, save=save, nt=nt, fw=False)
# Set up PDE expression and rearrange
pde = wave_kernel(model, v, q=q, fw=False)
# Setup source and receiver
geom_expr, _, rcv = src_rec(model,
v,
src_coords=rcv_coords,
nt=nt,
rec_coords=src_coords,
wavelet=y,
fw=False)
# Extended source
wsrc, ws_expr = extended_src_weights(model, ws, v)
# Wavefield norm
nv_t, nv_s = ([], [])
if norm_v:
weights = weight_fun(w_fun, model, src_coords)
norm_v, (nv_t, nv_s) = weighted_norm(v, weight=weights)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + ws_expr + nv_t + geom_expr + nv_s,
subs=subs,
name="adjoint" + name(model),
opt=opt_op(model))
# Run operator
summary = op()
# Output
if wsrc:
return wsrc, summary
if norm_v:
return rcv, v, norm_v.data[0], summary
return rcv, v, summary
def gradient(model,
residual,
rcv_coords,
u,
dt=None,
space_order=8,
w=1,
return_op=False,
w_symb=False):
"""
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
if w_symb:
w = Constant(name="w", value=w)
# Setting adjoint wavefield
v = wavefield(model, space_order, fw=False)
u = u or wavefield(model, space_order, save=True, nt=residual.shape[0])
# Set up PDE expression and rearrange
pde = wave_kernel(model, v, fw=False)
# Setup source and receiver
geom_expr, _, _ = src_rec(model,
v,
src_coords=rcv_coords,
wavelet=residual,
fw=False)
# Setup gradient wrt m
gradm = Function(name="gradm", grid=model.grid)
g_expr = grad_expr(gradm, u, v, w=w)
# Create operator and run
subs = model.spacing_map
op = create_op(pde + g_expr + geom_expr,
subs=subs,
name="gradient" + name(model))
if return_op:
return op
op()
# Output
return gradm.data
def forward_grad(model,
src_coords,
rcv_coords,
wavelet,
v,
space_order=8,
q=None,
ws=None,
isic=False,
w=None,
freq=None,
**kwargs):
"""
Low level propagator, to be used through `interface.py`
Compute forward wavefield u = A(m)^{-1}*f and related quantities (u(xrcv))
"""
# Number of time steps
nt = as_tuple(q)[0].shape[0] if wavelet is None else wavelet.shape[0]
# Setting forward wavefield
u = wavefield(model, space_order, save=False)
# Add extended source
q = q or wf_as_src(u, w=0)
q = extented_src(model, ws, wavelet, q=q)
# Set up PDE expression and rearrange
pde = wave_kernel(model, u, q=q)
# Setup source and receiver
geom_expr, _, rcv = src_rec(model,
u,
src_coords=src_coords,
nt=nt,
rec_coords=rcv_coords,
wavelet=wavelet)
# Setup gradient wrt m
gradm = Function(name="gradm", grid=model.grid)
g_expr = grad_expr(gradm, v, u, model, w=w, isic=isic, freq=freq)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + geom_expr + g_expr,
subs=subs,
name="forward_grad" + name(model),
opt=opt_op(model))
summary = op()
# Output
return rcv, gradm, summary
def adjoint_y(model,
y,
src_coords,
rcv_coords,
weight_fun_pars=None,
dt=None,
space_order=8,
save=False,
return_op=False):
"""
Compute adjoint wavefield v = adjoint(F(m))*y
and related quantities (||v||_w, v(xsrc))
"""
# Setting adjoint wavefield
v = wavefield(model, space_order, save=save, nt=y.shape[0], fw=False)
# Set up PDE expression and rearrange
pde = wave_kernel(model, v, fw=False)
# Setup source and receiver
geom_expr, _, rcv = src_rec(model,
v,
src_coords=rcv_coords,
rec_coords=src_coords,
wavelet=y,
fw=False)
# Setup ||v||_w computation
weights = weight_fun(weight_fun_pars, model, src_coords)
norm_v, norm_v_expr = weighted_norm(v, weight=weights)
# Create operator and run
subs = model.spacing_map
op = create_op(pde + geom_expr + norm_v_expr,
subs=subs,
name="adjoint_y" + name(model))
if return_op:
return op
op()
# Output
if save:
return norm_v.data[0], rcv.data, v
else:
return norm_v.data[0], rcv.data, None
def objTWRIdual_devito(model, y, src_coords, rcv_coords, wav,
dat, Filter, eps, mode="eval", objfact=np.float32(1),
comp_alpha=True, grad_corr=False, weight_fun_pars=None,
dt=None, space_order=8):
"""
Evaluate TWRI objective functional/gradients for current (m, y)
"""
# Setting time sampling
if dt is None:
dt = model.critical_dt
# Computing y in reduced mode (= residual) if not provided
u0 = None
y_was_None = y is None
if y_was_None:
u0rcv, u0 = forward(model, src_coords, rcv_coords, wav, dt=dt,
space_order=space_order, save=(mode == "grad") and grad_corr)
y = applyfilt(dat-u0rcv, Filter)
PTy = applyfilt_transp(y, Filter)
else:
PTy = y
# Normalization constants
nx = np.float32(model.vp.size)
nt, nr = np.float32(y.shape)
etaf = npla.norm(wav.reshape(-1)) / np.sqrt(nt * nx)
etad = npla.norm(applyfilt(dat, Filter).reshape(-1)) / np.sqrt(nt * nr)
# Compute wavefield vy = adjoint(F(m))*Py
norm_vPTy2, vPTy_src, vPTy = adjoint_y(model, PTy, src_coords, rcv_coords,
weight_fun_pars=weight_fun_pars, dt=dt,
space_order=space_order, save=(mode == "grad"))
# <PTy, d-F(m)*f> = <PTy, d>-<adjoint(F(m))*PTy, f>
PTy_dot_r = (np.dot(PTy.reshape(-1), dat.reshape(-1)) -
np.dot(vPTy_src.reshape(-1), wav.reshape(-1)))
# ||y||
norm_y = npla.norm(y.reshape(-1))
# Optimal alpha
c1 = etaf**np.float32(2) / (np.float32(4) * etad**np.float32(2) * nx * nt)
c2 = np.float32(1) / (etad * nr * nt)
c3 = eps / np.sqrt(nr * nt)
alpha = compute_optalpha(c1*norm_vPTy2, c2*PTy_dot_r, c3*norm_y,
comp_alpha=comp_alpha)
# Lagrangian evaluation
fun = (alpha * (-alpha * c1 * norm_vPTy2 + c2 * PTy_dot_r) -
np.abs(alpha) * c3 * norm_y)
# Gradient computation
if mode == "grad":
# Set up extebded source
w = 2.0 * c1 / c2 * alpha
if weight_fun_pars is not None:
w /= weight_fun(weight_fun_pars, model, src_coords)**2
Q = wf_as_src(vPTy, w=w)
# Setup gradient wrt m
u = wavefield(model, space_order)
gradm = Function(name="gradm", grid=model.grid)
g_exp = grad_expr(gradm, u, vPTy, w=alpha * c2)
rcv, _ = forward(model, src_coords, rcv_coords, wav, dt=dt,
space_order=space_order, q=Q, extra_expr=g_exp, u=u)
# Compute gradient wrt y
if not y_was_None or grad_corr:
norm_y = npla.norm(y)
grady_data = alpha * c2 * applyfilt(dat - rcv.data, Filter)
if norm_y != 0:
grady_data -= np.abs(alpha) * c3 * y / norm_y
# Correcting for reduced gradient
if not y_was_None or (y_was_None and not grad_corr):
gradm_data = gradm.data
else:
gradm_corr = gradient(model, applyfilt_transp(grady_data, Filter), rcv_coords,
u0, dt=dt, space_order=space_order, w=1)
# Reduced gradient post-processing
gradm_data = gradm.data + gradm_corr.data
# Return output
if mode == "eval":
return fun / objfact
elif mode == "grad" and y_was_None:
return fun / objfact, gradm_data / objfact
elif mode == "grad" and not y_was_None:
return fun / objfact, gradm_data / objfact, grady_data / objfact
def born(model,
src_coords,
rcv_coords,
wavelet,
space_order=8,
save=False,
q=None,
return_op=False,
isic=False,
freq_list=None,
dft_sub=None,
ws=None,
t_sub=1,
nlind=False):
"""
Low level propagator, to be used through `interface.py`
Compute linearized wavefield U = J(m)* δ m
and related quantities.
"""
nt = wavelet.shape[0]
# Setting wavefield
u = wavefield(model, space_order, save=save, nt=nt, t_sub=t_sub)
ul = wavefield(model, space_order, name="l")
# Expression for saving wavefield if time subsampling is used
u_save, eq_save = wavefield_subsampled(model, u, nt, t_sub)
# Extended source
q = q or wf_as_src(u, w=0)
q = extented_src(model, ws, wavelet, q=q)
# Set up PDE expression and rearrange
pde = wave_kernel(model, u, q=q)
if model.dm == 0:
pdel = []
else:
pdel = wave_kernel(model, ul, q=lin_src(model, u, isic=isic))
# Setup source and receiver
geom_expr, _, rcvnl = src_rec(model,
u,
rec_coords=rcv_coords if nlind else None,
src_coords=src_coords,
wavelet=wavelet)
geom_exprl, _, rcvl = src_rec(model, ul, rec_coords=rcv_coords, nt=nt)
# On-the-fly Fourier
dft, dft_modes = otf_dft(u, freq_list, model.critical_dt, factor=dft_sub)
# Create operator and run
subs = model.spacing_map
op = Operator(pde + geom_expr + geom_exprl + pdel + dft + eq_save,
subs=subs,
name="born" + name(model),
opt=opt_op(model))
op.cfunction
outrec = (rcvl, rcvnl) if nlind else rcvl
if return_op:
return op, u, outrec
summary = op()
# Output
return outrec, dft_modes or (u_save if t_sub > 1 else u), summary
