def __init__(self,
domain_shape: np.ndarray,
reg_mode: str = '',
alpha=0.01,
tau: float = None):
self._reg_mode = None
self.domain_shape = domain_shape
self.alpha = alpha
self.tau = tau
self.reg_mode = reg_mode
self.solver = None
if type(alpha) is not float:
if self.alpha.shape == domain_shape:
self.alpha = Diagonal(self.alpha.ravel())
else:
msg = "shape of local parameter alpha does not match: "+ \
str(self.alpha.shape) + "!=" + str(domain_shape)
raise ValueError(msg)
def __init__(self,
domain_shape: np.ndarray,
image_shape: np.ndarray = None,
reg_mode: str = '',
possible_reg_modes: list = None,
alpha: float = 1,
lam: float = 1,
tau: float = None):
self._reg_mode = None
self._alpha = None
self._lam = None
self.local_alpha = False # local regularization of regularization term
self.local_lam = False # local regularization of data fidelity
self.possible_reg_modes = possible_reg_modes
self.domain_shape = domain_shape
self.reg_mode = reg_mode
# weights
self.lam = lam
self.alpha = alpha
self.solver = None
self.tau = 1 # tmp
self.set_up_operator()
if isinstance(tau, (float, int)):
self.tau = tau
elif tau == 'auto':
self.tau = 1/np.sqrt(12) # see references - only 2d TGV
elif tau == 'calc':
self.tau = self.calc_tau()
elif tau == 'relax':
raise NotImplementedError("relax is not implemented yet")
sk = self.K.tosparse()
t = 1/sk.sum(axis=1)
self.tau = Diagonal(t)
else:
msg = "expected tau to be int, float or in ['calc', 'auto']."
self.solver = None
self.set_up_operator()
self.K = None
def PrestackInversion(data,
theta,
wav,
m0=None,
linearization='akirich',
explicit=False,
simultaneous=False,
epsI=None,
epsR=None,
dottest=False,
returnres=False,
epsRL1=None,
kind='centered',
**kwargs_solver):
r"""Pre-stack linearized seismic inversion.
Invert pre-stack seismic operator to retrieve a set of elastic property
profiles from band-limited seismic pre-stack data (i.e., angle gathers).
Depending on the choice of input parameters, inversion can be
trace-by-trace with explicit operator or global with either
explicit or linear operator.
Parameters
----------
data : :obj:`np.ndarray`
Band-limited seismic post-stack data of size
:math:`[(n_{lins} \times) n_{t0} \times n_{\theta} (\times n_x \times n_y)]`
theta : :obj:`np.ndarray`
Incident angles in degrees
wav : :obj:`np.ndarray`
Wavelet in time domain (must had odd number of elements
and centered to zero)
m0 : :obj:`np.ndarray`, optional
Background model of size :math:`[n_{t0} \times n_{m}
(\times n_x \times n_y)]`
linearization : :obj:`str` or :obj:`list`, optional
choice of linearization, ``akirich``: Aki-Richards, ``fatti``: Fatti
``PS``: PS or a combination of them (required only when ``m0``
is ``None``).
explicit : :obj:`bool`, optional
Create a chained linear operator (``False``, preferred for large data)
or a ``MatrixMult`` linear operator with dense matrix
(``True``, preferred for small data)
simultaneous : :obj:`bool`, optional
Simultaneously invert entire data (``True``) or invert
trace-by-trace (``False``) when using ``explicit`` operator
(note that the entire data is always inverted when working
with linear operator)
epsI : :obj:`float` or :obj:`list`, optional
Damping factor(s) for Tikhonov regularization term. If a list of
:math:`n_{m}` elements is provided, the regularization term will have
different strenght for each elastic property
epsR : :obj:`float`, optional
Damping factor for additional Laplacian regularization term
dottest : :obj:`bool`, optional
Apply dot-test
returnres : :obj:`bool`, optional
Return residuals
epsRL1 : :obj:`float`, optional
Damping factor for additional blockiness regularization term
kind : :obj:`str`, optional
Derivative kind (``forward`` or ``centered``).
**kwargs_solver
Arbitrary keyword arguments for :py:func:`scipy.linalg.lstsq`
solver (if ``explicit=True`` and ``epsR=None``)
or :py:func:`scipy.sparse.linalg.lsqr` solver (if ``explicit=False``
and/or ``epsR`` is not ``None``))
Returns
-------
minv : :obj:`np.ndarray`
Inverted model of size :math:`[n_{t0} \times n_{m}
(\times n_x \times n_y)]`
datar : :obj:`np.ndarray`
Residual data (i.e., data - background data) of
size :math:`[n_{t0} \times n_{\theta} (\times n_x \times n_y)]`
Notes
-----
The different choices of cost functions and solvers used in the
seismic pre-stack inversion module follow the same convention of the
seismic post-stack inversion module.
Refer to :py:func:`pylops.avo.poststack.PoststackInversion` for
more details.
"""
ncp = get_array_module(data)
# find out dimensions
if m0 is None and linearization is None:
raise NotImplementedError('either m0 or linearization '
'must be provided')
elif m0 is None:
if isinstance(linearization, str):
nm = _linearizations[linearization]
else:
nm = _linearizations[linearization[0]]
else:
nm = m0.shape[1]
data_shape = data.shape
data_ndim = data.ndim
n_lins = 1
multi = 0
if not isinstance(linearization, str):
n_lins = data_shape[0]
data_shape = data_shape[1:]
data_ndim -= 1
multi = 1
if data_ndim == 2:
dims = 1
nt0, ntheta = data_shape
nspat = None
nspatprod = nx = 1
elif data_ndim == 3:
dims = 2
nt0, ntheta, nx = data_shape
nspat = (nx, )
nspatprod = nx
else:
dims = 3
nt0, ntheta, nx, ny = data_shape
nspat = (nx, ny)
nspatprod = nx * ny
data = data.reshape(nt0, ntheta, nspatprod)
# check if background model and data have same shape
if m0 is not None:
if nt0 != m0.shape[0] or\
(dims >= 2 and nx != m0.shape[2]) or\
(dims == 3 and ny != m0.shape[3]):
raise ValueError('data and m0 must have same time and space axes')
# create operator
if isinstance(linearization, str):
# single operator
PPop = PrestackLinearModelling(wav,
theta,
nt0=nt0,
spatdims=nspat,
linearization=linearization,
explicit=explicit,
kind=kind)
else:
# multiple operators
if not isinstance(wav, (list, tuple)):
wav = [
wav,
] * n_lins
PPop = [
PrestackLinearModelling(w,
theta,
nt0=nt0,
spatdims=nspat,
linearization=lin,
explicit=explicit)
for w, lin in zip(wav, linearization)
]
if explicit:
PPop = MatrixMult(np.vstack([Op.A for Op in PPop]),
dims=nspat,
dtype=PPop[0].A.dtype)
else:
PPop = VStack(PPop)
if dottest:
Dottest(PPop,
n_lins * nt0 * ntheta * nspatprod,
nt0 * nm * nspatprod,
raiseerror=True,
verb=True,
backend=get_module_name(ncp))
# swap axes for explicit operator
if explicit:
data = data.swapaxes(0 + multi, 1 + multi)
if m0 is not None:
m0 = m0.swapaxes(0, 1)
# invert model
if epsR is None:
# create and remove background data from original data
datar = data.flatten() if m0 is None else \
data.flatten() - PPop * m0.flatten()
# inversion without spatial regularization
if explicit:
if epsI is None and not simultaneous:
# solve unregularized equations indipendently trace-by-trace
minv = \
get_lstsq(data)(PPop.A,
datar.reshape(n_lins*nt0*ntheta, nspatprod).squeeze(),
**kwargs_solver)[0]
elif epsI is None and simultaneous:
# solve unregularized equations simultaneously
if ncp == np:
minv = lsqr(PPop, datar, **kwargs_solver)[0]
else:
minv = cgls(PPop,
datar,
x0=ncp.zeros(int(PPop.shape[1]), PPop.dtype),
**kwargs_solver)[0]
elif epsI is not None:
# create regularized normal equations
PP = ncp.dot(PPop.A.T, PPop.A) + \
epsI * ncp.eye(nt0*nm, dtype=PPop.A.dtype)
datarn = np.dot(PPop.A.T,
datar.reshape(nt0 * ntheta, nspatprod))
if not simultaneous:
# solve regularized normal eqs. trace-by-trace
minv = get_lstsq(data)(PP, datarn, **kwargs_solver)[0]
else:
# solve regularized normal equations simultaneously
PPop_reg = MatrixMult(PP, dims=nspatprod)
if ncp == np:
minv = lsqr(PPop_reg, datarn.ravel(),
**kwargs_solver)[0]
else:
minv = cgls(PPop_reg,
datarn.ravel(),
x0=ncp.zeros(int(PPop_reg.shape[1]),
PPop_reg.dtype),
**kwargs_solver)[0]
#else:
# # create regularized normal eqs. and solve them simultaneously
# PP = np.dot(PPop.A.T, PPop.A) + epsI * np.eye(nt0*nm)
# datarn = PPop.A.T * datar.reshape(nt0*ntheta, nspatprod)
# PPop_reg = MatrixMult(PP, dims=ntheta*nspatprod)
# minv = lstsq(PPop_reg, datarn.flatten(), **kwargs_solver)[0]
else:
# solve unregularized normal equations simultaneously with lop
if ncp == np:
minv = lsqr(PPop, datar, **kwargs_solver)[0]
else:
minv = cgls(PPop,
datar,
x0=ncp.zeros(int(PPop.shape[1]), PPop.dtype),
**kwargs_solver)[0]
else:
# Create Thicknov regularization
if epsI is not None:
if isinstance(epsI, (list, tuple)):
if len(epsI) != nm:
raise ValueError('epsI must be a scalar or a list of'
'size nm')
RegI = Diagonal(np.array(epsI),
dims=(nt0, nm, nspatprod),
dir=1)
else:
RegI = epsI * Identity(nt0 * nm * nspatprod)
if epsRL1 is None:
# L2 inversion with spatial regularization
if dims == 1:
Regop = SecondDerivative(nt0 * nm,
dtype=PPop.dtype,
dims=(nt0, nm))
elif dims == 2:
Regop = Laplacian((nt0, nm, nx), dirs=(0, 2), dtype=PPop.dtype)
else:
Regop = Laplacian((nt0, nm, nx, ny),
dirs=(2, 3),
dtype=PPop.dtype)
if epsI is None:
Regop = (Regop, )
epsR = (epsR, )
else:
Regop = (Regop, RegI)
epsR = (epsR, 1)
minv = \
RegularizedInversion(PPop, Regop, data.ravel(),
x0=m0.flatten() if m0 is not None
else None, epsRs=epsR,
returninfo=False, **kwargs_solver)
else:
# Blockiness-promoting inversion with spatial regularization
if dims == 1:
RegL1op = FirstDerivative(nt0 * nm, dtype=PPop.dtype)
RegL2op = None
elif dims == 2:
RegL1op = FirstDerivative(nt0 * nx * nm,
dims=(nt0, nm, nx),
dir=0,
dtype=PPop.dtype)
RegL2op = SecondDerivative(nt0 * nx * nm,
dims=(nt0, nm, nx),
dir=2,
dtype=PPop.dtype)
else:
RegL1op = FirstDerivative(nt0 * nx * ny * nm,
dims=(nt0, nm, nx, ny),
dir=0,
dtype=PPop.dtype)
RegL2op = Laplacian((nt0, nm, nx, ny),
dirs=(2, 3),
dtype=PPop.dtype)
if dims == 1:
if epsI is not None:
RegL2op = (RegI, )
epsR = (1, )
else:
if epsI is None:
RegL2op = (RegL2op, )
epsR = (epsR, )
else:
RegL2op = (RegL2op, RegI)
epsR = (epsR, 1)
epsRL1 = (epsRL1, )
if 'mu' in kwargs_solver.keys():
mu = kwargs_solver['mu']
kwargs_solver.pop('mu')
else:
mu = 1.
if 'niter_outer' in kwargs_solver.keys():
niter_outer = kwargs_solver['niter_outer']
kwargs_solver.pop('niter_outer')
else:
niter_outer = 3
if 'niter_inner' in kwargs_solver.keys():
niter_inner = kwargs_solver['niter_inner']
kwargs_solver.pop('niter_inner')
else:
niter_inner = 5
minv = SplitBregman(PPop, (RegL1op, ),
data.ravel(),
RegsL2=RegL2op,
epsRL1s=epsRL1,
epsRL2s=epsR,
mu=mu,
niter_outer=niter_outer,
niter_inner=niter_inner,
x0=None if m0 is None else m0.flatten(),
**kwargs_solver)[0]
# compute residual
if returnres:
if epsR is None:
datar -= PPop * minv.ravel()
else:
datar = data.ravel() - PPop * minv.ravel()
# re-swap axes for explicit operator
if explicit:
if m0 is not None:
m0 = m0.swapaxes(0, 1)
# reshape inverted model and residual data
if dims == 1:
if explicit:
minv = minv.reshape(nm, nt0).swapaxes(0, 1)
if returnres:
datar = datar.reshape(n_lins, ntheta, nt0).squeeze().swapaxes(
0 + multi, 1 + multi)
else:
minv = minv.reshape(nt0, nm)
if returnres:
datar = datar.reshape(n_lins, nt0, ntheta).squeeze()
elif dims == 2:
if explicit:
minv = minv.reshape(nm, nt0, nx).swapaxes(0, 1)
if returnres:
datar = datar.reshape(n_lins, ntheta, nt0,
nx).squeeze().swapaxes(
0 + multi, 1 + multi)
else:
minv = minv.reshape(nt0, nm, nx)
if returnres:
datar = datar.reshape(n_lins, nt0, ntheta, nx).squeeze()
else:
if explicit:
minv = minv.reshape(nm, nt0, nx, ny).swapaxes(0, 1)
if returnres:
datar = datar.reshape(n_lins, ntheta, nt0, nx,
ny).squeeze().swapaxes(
0 + multi, 1 + multi)
else:
minv = minv.reshape(nt0, nm, nx, ny)
if returnres:
datar = datar.reshape(n_lins, nt0, ntheta, nx, ny).squeeze()
if m0 is not None and epsR is None:
minv = minv + m0
if returnres:
return minv, datar
else:
return minv
def UpDownComposition2D(nt,
nr,
dt,
dr,
rho,
vel,
nffts=(None, None),
critical=100.,
ntaper=10,
scaling=1.,
dtype='complex128'):
r"""2D Up-down wavefield composition.
Apply multi-component seismic wavefield composition from its
up- and down-going constituents. This input model required by the operator
should be created by flattening the concatenated separated wavefields of
size :math:`\lbrack n_r \times n_t \rbrack` along the spatial axis.
Similarly, the data is also a concatenation of flattened pressure and
vertical particle velocity wavefields.
Parameters
----------
nt : :obj:`int`
Number of samples along the time axis
nr : :obj:`int`
Number of samples along the receiver axis
dt : :obj:`float`
Sampling along the time axis
dr : :obj:`float`
Sampling along the receiver array
rho : :obj:`float`
Density along the receiver array (must be constant)
vel : :obj:`float`
Velocity along the receiver array (must be constant)
nffts : :obj:`tuple`, optional
Number of samples along the wavenumber and frequency axes
critical : :obj:`float`, optional
Percentage of angles to retain in obliquity factor. For example, if
``critical=100`` only angles below the critical angle
:math`\frac{f(k_x)}{vel}` will be retained
ntaper : :obj:`float`, optional
Number of samples of taper applied to obliquity factor around critical
angle
scaling : :obj:`float`, optional
Scaling to apply to the operator (see Notes for more details)
dtype : :obj:`str`, optional
Type of elements in input array.
Returns
-------
UDop : :obj:`pylops.LinearOperator`
Up-down wavefield composition operator
See Also
--------
WavefieldDecomposition: Wavefield decomposition
Notes
-----
Multi-component seismic data (:math:`p(x, t)` and :math:`v_z(x, t)`) can be
synthesized in the frequency-wavenumber domain
as the superposition of the up- and downgoing constituents of
the pressure wavefield (:math:`p^-(x, t)` and :math:`p^+(x, t)`)
as follows [1]_:
.. math::
\begin{bmatrix}
\mathbf{p}(k_x, \omega) \\
\mathbf{v_z}(k_x, \omega)
\end{bmatrix} =
\begin{bmatrix}
1 & 1 \\
\frac{k_z}{\omega \rho} & - \frac{k_z}{\omega \rho} \\
\end{bmatrix}
\begin{bmatrix}
\mathbf{p^+}(k_x, \omega) \\
\mathbf{p^-}(k_x, \omega)
\end{bmatrix}
which we can write in a compact matrix-vector notation as:
.. math::
\begin{bmatrix}
\mathbf{p} \\
s*\mathbf{v_z}
\end{bmatrix} =
\begin{bmatrix}
\mathbf{F} & 0 \\
0 & s*\mathbf{F}
\end{bmatrix} \mathbf{W} \begin{bmatrix}
\mathbf{F}^H & 0 \\
0 & \mathbf{F}^H
\end{bmatrix} \mathbf{p^{\pm}}
where :math:`\mathbf{F}` is the 2-dimensional FFT
(:class:`pylops.signalprocessing.FFT2`),
:math:`\mathbf{W}` is a weighting matrix implemented
via :class:`pylops.basicprocessing.Diagonal`, and :math:`s` is a scaling
factor that is applied to both the particle velocity data and to the
operator has shown above. Such a scaling is required to balance out the
different dynamic range of pressure and particle velocity when solving the
wavefield separation problem as an inverse problem.
As the operator is effectively obtained by chaining basic PyLops operators
the adjoint is automatically implemented for this operator.
.. [1] Wapenaar, K. "Reciprocity properties of one-way propagators",
Geophysics, vol. 63, pp. 1795-1798. 1998.
"""
nffts = (int(nffts[0]) if nffts[0] is not None else nr,
int(nffts[1]) if nffts[1] is not None else nt)
# create obliquity operator
FFTop = FFT2D(dims=[nr, nt], nffts=nffts, sampling=[dr, dt], dtype=dtype)
[Kx, F] = np.meshgrid(FFTop.f1, FFTop.f2, indexing='ij')
k = F / vel
Kz = np.sqrt((k**2 - Kx**2).astype(np.complex))
Kz[np.isnan(Kz)] = 0
OBL = Kz / (rho * np.abs(F))
OBL[F == 0] = 0
# cut off and taper
OBL = _filter_obliquity(OBL, F, Kx, vel, critical, ntaper)
OBLop = Diagonal(OBL.ravel(), dtype=dtype)
# create up-down modelling operator
UDop = (BlockDiag([FFTop.H, scaling*FFTop.H]) * \
Block([[Identity(nffts[0]*nffts[1], dtype=dtype),
Identity(nffts[0]*nffts[1], dtype=dtype)],
[OBLop, -OBLop]]) * \
BlockDiag([FFTop, FFTop]))
return UDop
def Deghosting(
p,
nt,
nr,
dt,
dr,
vel,
zrec,
pd=None,
win=None,
npad=(11, 11),
ntaper=(11, 11),
restriction=None,
sptransf=None,
solver=lsqr,
dottest=False,
dtype="complex128",
**kwargs_solver
):
r"""Wavefield deghosting.
Apply seismic wavefield decomposition from single-component (pressure)
data. This process is also generally referred to as model-based deghosting.
Parameters
----------
p : :obj:`np.ndarray`
Pressure data of of size :math:`\lbrack n_{r_x}\,(\times n_{r_y})
\times n_t \rbrack` (or :math:`\lbrack n_{r_{x,\text{sub}}}\,
(\times n_{r_{y,\text{sub}}}) \times n_t \rbrack`
in case a ``restriction`` operator is provided. Note that
:math:`n_{r_{x,\text{sub}}}` (and :math:`n_{r_{y,\text{sub}}}`)
must agree with the size of the output of this operator)
nt : :obj:`int`
Number of samples along the time axis
nr : :obj:`int` or :obj:`tuple`
Number of samples along the receiver axis (or axes)
dt : :obj:`float`
Sampling along the time axis
dr : :obj:`float` or :obj:`tuple`
Sampling along the receiver array of the separated
pressure consituents
vel : :obj:`float`
Velocity along the receiver array (must be constant)
zrec : :obj:`float`
Depth of receiver array
pd : :obj:`np.ndarray`, optional
Direct arrival to be subtracted from ``p``
win : :obj:`np.ndarray`, optional
Time window to be applied to ``p`` to remove the direct arrival
(if ``pd=None``)
ntaper : :obj:`float` or :obj:`tuple`, optional
Number of samples of taper applied to propagator to avoid edge
effects
npad : :obj:`float` or :obj:`tuple`, optional
Number of samples of padding applied to propagator to avoid edge
effects
angle
restriction : :obj:`pylops.LinearOperator`, optional
Restriction operator
sptransf : :obj:`pylops.LinearOperator`, optional
Sparsifying operator
solver : :obj:`float`, optional
Function handle of solver to be used if ``kind='inverse'``
dottest : :obj:`bool`, optional
Apply dot-test
dtype : :obj:`str`, optional
Type of elements in input array. If ``None``, directly inferred
from ``p``
**kwargs_solver
Arbitrary keyword arguments for chosen ``solver``
Returns
-------
pup : :obj:`np.ndarray`
Up-going wavefield
pdown : :obj:`np.ndarray`
Down-going wavefield
Notes
-----
Up- and down-going components of seismic data :math:`p^-(x, t)`
and :math:`p^+(x, t)` can be estimated from single-component data
:math:`p(x, t)` using a ghost model.
The basic idea [1]_ is that of using a one-way propagator in the f-k domain
(also referred to as ghost model) to predict the down-going field
from the up-going one (excluded the direct arrival and its source
ghost referred here to as :math:`p_d(x, t)`):
.. math::
p^+ - p_d = e^{-j k_z 2 z_\text{rec}} p^-
where :math:`k_z` is the vertical wavenumber and :math:`z_\text{rec}` is the
depth of the array of receivers
In a matrix form we can thus write the total wavefield as:
.. math::
\mathbf{p} - \mathbf{p_d} = (\mathbf{I} + \Phi) \mathbf{p}^-
where :math:`\Phi` is one-way propagator implemented via the
:class:`pylops.waveeqprocessing.PhaseShift` operator.
.. [1] Amundsen, L., 1993, Wavenumber-based filtering of marine point-source
data: GEOPHYSICS, 58, 1335–1348.
"""
ndims = p.ndim
if ndims == 2:
dims = (nt, nr)
nrs = nr
nkx = nr + 2 * npad
kx = np.fft.ifftshift(np.fft.fftfreq(nkx, dr))
ky = None
else:
dims = (nt, nr[0], nr[1])
nrs = nr[0] * nr[1]
nkx = nr[0] + 2 * npad[0]
kx = np.fft.ifftshift(np.fft.fftfreq(nkx, dr[0]))
nky = nr[1] + 2 * npad[1]
ky = np.fft.ifftshift(np.fft.fftfreq(nky, dr))
nf = nt
freq = np.fft.rfftfreq(nf, dt)
# Phase shift operator
zprop = 2 * zrec
if ndims == 2:
taper = taper2d(nt, nr, ntaper).T
Padop = Pad(dims, ((0, 0), (npad, npad)))
else:
taper = taper3d(nt, nr, ntaper).transpose(2, 0, 1)
Padop = Pad(dims, ((0, 0), (npad[0], npad[0]), (npad[1], npad[1])))
Pop = (
-Padop.H
* PhaseShift(vel, zprop, nt, freq, kx, ky)
* Padop
* Diagonal(taper.ravel(), dtype=dtype)
)
# Decomposition operator
Dupop = Identity(nt * nrs, dtype=p.dtype) + Pop
if dottest:
Dottest(Dupop, nt * nrs, nt * nrs, verb=True)
# Add restriction
if restriction is not None:
Dupop_norestr = Dupop
Dupop = restriction * Dupop
# Add sparsify transform
if sptransf is not None:
Dupop_norestr = Dupop_norestr * sptransf
Dupop = Dupop * sptransf
# Define data
if pd is not None:
d = p - pd
else:
d = win * p
# Inversion
pup = solver(Dupop, d.ravel(), **kwargs_solver)[0]
# Apply sparse transform
if sptransf is not None:
p = Dupop_norestr * pup # reconstruct p at finely sampled spatial axes
pup = sptransf * pup
p = np.real(p).reshape(dims)
# Finalize estimates
pup = np.real(pup).reshape(dims)
pdown = p - pup
return pup, pdown
def MDD(
G,
d,
dt=0.004,
dr=1.0,
nfmax=None,
wav=None,
twosided=True,
causality_precond=False,
adjoint=False,
psf=False,
dtype="float64",
dottest=False,
saveGt=True,
add_negative=True,
smooth_precond=0,
fftengine="numpy",
**kwargs_solver
):
r"""Multi-dimensional deconvolution.
Solve multi-dimensional deconvolution problem using
:py:func:`scipy.sparse.linalg.lsqr` iterative solver.
Parameters
----------
G : :obj:`numpy.ndarray`
Multi-dimensional convolution kernel in time domain of size
:math:`[n_s \times n_r \times n_t]` for ``twosided=False`` or
``twosided=True`` and ``add_negative=True``
(with only positive times) or size
:math:`[n_s \times n_r \times 2n_t-1]` for ``twosided=True`` and
``add_negative=False``
(with both positive and negative times)
d : :obj:`numpy.ndarray`
Data in time domain :math:`[n_s \,(\times n_{vs}) \times n_t]` if
``twosided=False`` or ``twosided=True`` and ``add_negative=True``
(with only positive times) or size
:math:`[n_s \,(\times n_{vs}) \times 2n_t-1]` if ``twosided=True``
dt : :obj:`float`, optional
Sampling of time integration axis
dr : :obj:`float`, optional
Sampling of receiver integration axis
nfmax : :obj:`int`, optional
Index of max frequency to include in deconvolution process
wav : :obj:`numpy.ndarray`, optional
Wavelet to convolve to the inverted model and psf
(must be centered around its index in the middle of the array).
If ``None``, the outputs of the inversion are returned directly.
twosided : :obj:`bool`, optional
MDC operator and data both negative and positive time (``True``)
or only positive (``False``)
add_negative : :obj:`bool`, optional
Add negative side to MDC operator and data (``True``) or not
(``False``)- operator and data are already provided with both positive
and negative sides. To be used only with ``twosided=True``.
causality_precond : :obj:`bool`, optional
Apply causality mask (``True``) or not (``False``)
smooth_precond : :obj:`int`, optional
Lenght of smoothing to apply to causality preconditioner
adjoint : :obj:`bool`, optional
Compute and return adjoint(s)
psf : :obj:`bool`, optional
Compute and return Point Spread Function (PSF) and its inverse
dtype : :obj:`bool`, optional
Type of elements in input array.
dottest : :obj:`bool`, optional
Apply dot-test
saveGt : :obj:`bool`, optional
Save ``G`` and ``G.H`` to speed up the computation of adjoint of
:class:`pylops.signalprocessing.Fredholm1` (``True``) or create
``G.H`` on-the-fly (``False``) Note that ``saveGt=True`` will be
faster but double the amount of required memory
fftengine : :obj:`str`, optional
Engine used for fft computation (``numpy``, ``scipy`` or ``fftw``)
**kwargs_solver
Arbitrary keyword arguments for chosen solver
(:py:func:`scipy.sparse.linalg.cg` and
:py:func:`pylops.optimization.solver.cg` are used as default for numpy
and cupy `data`, respectively)
Returns
-------
minv : :obj:`numpy.ndarray`
Inverted model of size :math:`[n_r \,(\times n_{vs}) \times n_t]`
for ``twosided=False`` or
:math:`[n_r \,(\times n_vs) \times 2n_t-1]` for ``twosided=True``
madj : :obj:`numpy.ndarray`
Adjoint model of size :math:`[n_r \,(\times n_{vs}) \times n_t]`
for ``twosided=False`` or
:math:`[n_r \,(\times n_r) \times 2n_t-1]` for ``twosided=True``
psfinv : :obj:`numpy.ndarray`
Inverted psf of size :math:`[n_r \times n_r \times n_t]`
for ``twosided=False`` or
:math:`[n_r \times n_r \times 2n_t-1]` for ``twosided=True``
psfadj : :obj:`numpy.ndarray`
Adjoint psf of size :math:`[n_r \times n_r \times n_t]`
for ``twosided=False`` or
:math:`[n_r \times n_r \times 2n_t-1]` for ``twosided=True``
See Also
--------
MDC : Multi-dimensional convolution
Notes
-----
Multi-dimensional deconvolution (MDD) is a mathematical ill-solved problem,
well-known in the image processing and geophysical community [1]_.
MDD aims at removing the effects of a Multi-dimensional Convolution
(MDC) kernel or the so-called blurring operator or point-spread
function (PSF) from a given data. It can be written as
.. math::
\mathbf{d}= \mathbf{D} \mathbf{m}
or, equivalently, by means of its normal equation
.. math::
\mathbf{m}= (\mathbf{D}^H\mathbf{D})^{-1} \mathbf{D}^H\mathbf{d}
where :math:`\mathbf{D}^H\mathbf{D}` is the PSF.
.. [1] Wapenaar, K., van der Neut, J., Ruigrok, E., Draganov, D., Hunziker,
J., Slob, E., Thorbecke, J., and Snieder, R., "Seismic interferometry
by crosscorrelation and by multi-dimensional deconvolution: a
systematic comparison", Geophyscial Journal International, vol. 185,
pp. 1335-1364. 2011.
"""
ncp = get_array_module(d)
ns, nr, nt = G.shape
if len(d.shape) == 2:
nv = 1
else:
nv = d.shape[1]
if twosided:
if add_negative:
nt2 = 2 * nt - 1
else:
nt2 = nt
nt = (nt2 + 1) // 2
nfmax_allowed = int(np.ceil((nt2 + 1) / 2))
else:
nt2 = nt
nfmax_allowed = nt
# Fix nfmax to be at maximum equal to half of the size of fft samples
if nfmax is None or nfmax > nfmax_allowed:
nfmax = nfmax_allowed
logging.warning("nfmax set equal to ceil[(nt+1)/2=%d]" % nfmax)
# Add negative part to data and model
if twosided and add_negative:
G = np.concatenate((ncp.zeros((ns, nr, nt - 1)), G), axis=-1)
d = np.concatenate((np.squeeze(np.zeros((ns, nv, nt - 1))), d), axis=-1)
# Bring kernel to frequency domain
Gfft = np.fft.rfft(G, nt2, axis=-1)
Gfft = Gfft[..., :nfmax]
# Bring frequency/time to first dimension
Gfft = np.moveaxis(Gfft, -1, 0)
d = np.moveaxis(d, -1, 0)
if psf:
G = np.moveaxis(G, -1, 0)
# Define MDC linear operator
MDCop = MDC(
Gfft,
nt2,
nv=nv,
dt=dt,
dr=dr,
twosided=twosided,
transpose=False,
saveGt=saveGt,
fftengine=fftengine,
)
if psf:
PSFop = MDC(
Gfft,
nt2,
nv=nr,
dt=dt,
dr=dr,
twosided=twosided,
transpose=False,
saveGt=saveGt,
fftengine=fftengine,
)
if dottest:
Dottest(
MDCop, nt2 * ns * nv, nt2 * nr * nv, verb=True, backend=get_module_name(ncp)
)
if psf:
Dottest(
PSFop,
nt2 * ns * nr,
nt2 * nr * nr,
verb=True,
backend=get_module_name(ncp),
)
# Adjoint
if adjoint:
madj = MDCop.H * d.ravel()
madj = np.squeeze(madj.reshape(nt2, nr, nv))
madj = np.moveaxis(madj, 0, -1)
if psf:
psfadj = PSFop.H * G.ravel()
psfadj = np.squeeze(psfadj.reshape(nt2, nr, nr))
psfadj = np.moveaxis(psfadj, 0, -1)
# Inverse
if twosided and causality_precond:
P = np.ones((nt2, nr, nv))
P[: nt - 1] = 0
if smooth_precond > 0:
P = filtfilt(np.ones(smooth_precond) / smooth_precond, 1, P, axis=0)
P = to_cupy_conditional(d, P)
Pop = Diagonal(P)
minv = PreconditionedInversion(
MDCop, Pop, d.ravel(), returninfo=False, **kwargs_solver
)
else:
if ncp == np and "callback" not in kwargs_solver:
minv = lsqr(MDCop, d.ravel(), **kwargs_solver)[0]
else:
minv = cgls(
MDCop,
d.ravel(),
ncp.zeros(int(MDCop.shape[1]), dtype=MDCop.dtype),
**kwargs_solver
)[0]
minv = np.squeeze(minv.reshape(nt2, nr, nv))
minv = np.moveaxis(minv, 0, -1)
if wav is not None:
wav1 = wav.copy()
for _ in range(minv.ndim - 1):
wav1 = wav1[ncp.newaxis]
minv = get_fftconvolve(d)(minv, wav1, mode="same")
if psf:
if ncp == np:
psfinv = lsqr(PSFop, G.ravel(), **kwargs_solver)[0]
else:
psfinv = cgls(
PSFop,
G.ravel(),
ncp.zeros(int(PSFop.shape[1]), dtype=PSFop.dtype),
**kwargs_solver
)[0]
psfinv = np.squeeze(psfinv.reshape(nt2, nr, nr))
psfinv = np.moveaxis(psfinv, 0, -1)
if wav is not None:
wav1 = wav.copy()
for _ in range(psfinv.ndim - 1):
wav1 = wav1[np.newaxis]
psfinv = get_fftconvolve(d)(psfinv, wav1, mode="same")
if adjoint and psf:
return minv, madj, psfinv, psfadj
elif adjoint:
return minv, madj
elif psf:
return minv, psfinv
else:
return minv
def _obliquity2D(nt,
nr,
dt,
dr,
rho,
vel,
nffts,
critical=100.,
ntaper=10,
composition=True,
dtype='complex128'):
"""2D Obliquity operator and FFT operator
Parameters
----------
nt : :obj:`int`
Number of samples along the time axis
nr : :obj:`int`
Number of samples along the receiver axis
dt : :obj:`float`
Sampling along the time axis
dr : :obj:`float`
Sampling along the receiver array
rho : :obj:`float`
Density along the receiver array (must be constant)
vel : :obj:`float`
Velocity along the receiver array (must be constant)
nffts : :obj:`tuple`, optional
Number of samples along the wavenumber and frequency axes
critical : :obj:`float`, optional
Percentage of angles to retain in obliquity factor. For example, if
``critical=100`` only angles below the critical angle
:math:`|k_x| < \frac{f(k_x)}{vel}` will be retained
ntaper : :obj:`float`, optional
Number of samples of taper applied to obliquity factor around critical
angle
composition : :obj:`bool`, optional
Create obliquity factor for composition (``True``) or
decomposition (``False``)
dtype : :obj:`str`, optional
Type of elements in input array.
Returns
-------
FFTop : :obj:`pylops.LinearOperator`
FFT operator
OBL : :obj:`np.ndarray`
Filtered obliquity factor
"""
# create Fourier operator
FFTop = FFT2D(dims=[nr, nt], nffts=nffts, sampling=[dr, dt], dtype=dtype)
# create obliquity operator
[Kx, F] = np.meshgrid(FFTop.f1, FFTop.f2, indexing='ij')
k = F / vel
Kz = np.sqrt((k**2 - Kx**2).astype(dtype))
Kz[np.isnan(Kz)] = 0
if composition:
OBL = Kz / (rho * np.abs(F))
OBL[F == 0] = 0
else:
OBL = rho * (np.abs(F) / Kz)
OBL[Kz == 0] = 0
# cut off and taper
OBL = _filter_obliquity(OBL, F, Kx, vel, critical, ntaper)
OBLop = Diagonal(OBL.ravel(), dtype=dtype)
return FFTop, OBLop
def apply_multiplepoints(self,
trav,
G0=None,
nfft=None,
rtm=False,
greens=False,
dottest=False,
**kwargs_lsqr):
r"""Marchenko redatuming for multiple points
Solve the Marchenko redatuming inverse problem for multiple
points given their direct arrival traveltime curves (``trav``)
and waveforms (``G0``).
Parameters
----------
trav : :obj:`numpy.ndarray`
Traveltime of first arrival from subsurface points to
surface receivers of size :math:`[n_r \times n_{vs}]`
G0 : :obj:`numpy.ndarray`, optional
Direct arrival in time domain of size
:math:`[n_r \times n_{vs} \times n_t]` (if None, create arrival
using ``trav``)
nfft : :obj:`int`, optional
Number of samples in fft when creating the analytical direct wave
rtm : :obj:`bool`, optional
Compute and return rtm redatuming
greens : :obj:`bool`, optional
Compute and return Green's functions
dottest : :obj:`bool`, optional
Apply dot-test
**kwargs_lsqr
Arbitrary keyword arguments
for :py:func:`scipy.sparse.linalg.lsqr` solver
Returns
----------
f1_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing focusing function of size
:math:`[n_r \times n_{vs} \times n_t]`
f1_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing focusing functionof size
:math:`[n_r \times n_{vs} \times n_t]`
p0_minus : :obj:`numpy.ndarray`
Single-scattering standard redatuming upgoing Green's function
of size :math:`[n_r \times n_{vs} \times n_t]`
g_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing Green's function of size
:math:`[n_r \times n_{vs} \times n_t]`
g_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing Green's function of size
:math:`[n_r \times n_{vs} \times n_t]`
"""
nvs = trav.shape[1]
# Create window
trav_off = trav - self.toff
trav_off = np.round(trav_off / self.dt).astype(np.int)
w = np.zeros((self.nr, nvs, self.nt))
for ir in range(self.nr):
for ivs in range(nvs):
w[ir, ivs, :trav_off[ir, ivs]] = 1
w = np.concatenate((np.flip(w, axis=-1), w[:, :, 1:]), axis=-1)
if self.nsmooth > 0:
smooth = np.ones(self.nsmooth) / self.nsmooth
w = filtfilt(smooth, 1, w)
# Create operators
Rop = MDC(self.Rtwosided_fft,
self.nt2,
nv=nvs,
dt=self.dt,
dr=self.dr,
twosided=True,
conj=False,
transpose=False,
prescaled=self.prescaled,
dtype=self.dtype)
R1op = MDC(self.Rtwosided_fft,
self.nt2,
nv=nvs,
dt=self.dt,
dr=self.dr,
twosided=True,
conj=True,
transpose=False,
prescaled=self.prescaled,
dtype=self.dtype)
Rollop = Roll(self.ns * nvs * self.nt2,
dims=(self.nt2, self.ns, nvs),
dir=0,
shift=-1,
dtype=self.dtype)
Wop = Diagonal(w.transpose(2, 0, 1).flatten())
Iop = Identity(self.nr * nvs * self.nt2)
Mop = Block([[Iop, -1 * Wop * Rop], [-1 * Wop * Rollop * R1op, Iop]
]) * BlockDiag([Wop, Wop])
Gop = Block([[Iop, -1 * Rop], [-1 * Rollop * R1op, Iop]])
if dottest:
Dottest(Gop,
2 * self.nr * nvs * self.nt2,
2 * self.nr * nvs * self.nt2,
raiseerror=True,
verb=True)
if dottest:
Dottest(Mop,
2 * self.ns * nvs * self.nt2,
2 * self.nr * nvs * self.nt2,
raiseerror=True,
verb=True)
# Create input focusing function
if G0 is None:
if self.wav is not None and nfft is not None:
G0 = np.zeros((self.nr, nvs, self.nt))
for ivs in range(nvs):
G0[:, ivs] = (directwave(self.wav,
trav[:, ivs],
self.nt,
self.dt,
nfft=nfft,
derivative=True)).T
else:
logging.error('wav and/or nfft are not provided. '
'Provide either G0 or wav and nfft...')
raise ValueError('wav and/or nfft are not provided. '
'Provide either G0 or wav and nfft...')
fd_plus = np.concatenate((np.flip(G0, axis=-1).transpose(2, 0, 1),
np.zeros((self.nt - 1, self.nr, nvs))))
# Run standard redatuming as benchmark
if rtm:
p0_minus = Rop * fd_plus.flatten()
p0_minus = p0_minus.reshape(self.nt2, self.ns,
nvs).transpose(1, 2, 0)
# Create data and inverse focusing functions
d = Wop * Rop * fd_plus.flatten()
d = np.concatenate((d.reshape(self.nt2, self.ns,
nvs), np.zeros(
(self.nt2, self.ns, nvs))))
# Invert for focusing functions
f1_inv = lsqr(Mop, d.flatten(), **kwargs_lsqr)[0]
f1_inv = f1_inv.reshape(2 * self.nt2, self.nr, nvs)
f1_inv_tot = \
f1_inv + np.concatenate((np.zeros((self.nt2, self.nr, nvs)),
fd_plus))
f1_inv_minus = f1_inv_tot[:self.nt2].transpose(1, 2, 0)
f1_inv_plus = f1_inv_tot[self.nt2:].transpose(1, 2, 0)
if greens:
# Create Green's functions
g_inv = Gop * f1_inv_tot.flatten()
g_inv = np.real(g_inv) # cast to real as Gop is a complex operator
g_inv = g_inv.reshape(2 * self.nt2, self.ns, nvs)
g_inv_minus = -g_inv[:self.nt2].transpose(1, 2, 0)
g_inv_plus = np.flip(g_inv[self.nt2:], axis=0).transpose(1, 2, 0)
if rtm and greens:
return f1_inv_minus, f1_inv_plus, p0_minus, g_inv_minus, g_inv_plus
elif rtm:
return f1_inv_minus, f1_inv_plus, p0_minus
elif greens:
return f1_inv_minus, f1_inv_plus, g_inv_minus, g_inv_plus
else:
return f1_inv_minus, f1_inv_plus
def apply_multiplepoints(self,
trav,
G0=None,
nfft=None,
rtm=False,
greens=False,
dottest=False,
usematmul=False,
**kwargs_solver):
r"""Marchenko redatuming for multiple points
Solve the Marchenko redatuming inverse problem for multiple
points given their direct arrival traveltime curves (``trav``)
and waveforms (``G0``).
Parameters
----------
trav : :obj:`numpy.ndarray`
Traveltime of first arrival from subsurface points to
surface receivers of size :math:`[n_r \times n_{vs}]`
G0 : :obj:`numpy.ndarray`, optional
Direct arrival in time domain of size
:math:`[n_r \times n_{vs} \times n_t]` (if None, create arrival
using ``trav``)
nfft : :obj:`int`, optional
Number of samples in fft when creating the analytical direct wave
rtm : :obj:`bool`, optional
Compute and return rtm redatuming
greens : :obj:`bool`, optional
Compute and return Green's functions
dottest : :obj:`bool`, optional
Apply dot-test
usematmul : :obj:`bool`, optional
Use :func:`numpy.matmul` (``True``) or for-loop with :func:`numpy.dot`
(``False``) in :py:class:`pylops.signalprocessing.Fredholm1` operator.
Refer to Fredholm1 documentation for details.
**kwargs_solver
Arbitrary keyword arguments for chosen solver
(:py:func:`scipy.sparse.linalg.lsqr` and
:py:func:`pylops.optimization.solver.cgls` are used as default
for numpy and cupy `data`, respectively)
Returns
----------
f1_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing focusing function of size
:math:`[n_r \times n_{vs} \times n_t]`
f1_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing focusing functionof size
:math:`[n_r \times n_{vs} \times n_t]`
p0_minus : :obj:`numpy.ndarray`
Single-scattering standard redatuming upgoing Green's function
of size :math:`[n_r \times n_{vs} \times n_t]`
g_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing Green's function of size
:math:`[n_r \times n_{vs} \times n_t]`
g_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing Green's function of size
:math:`[n_r \times n_{vs} \times n_t]`
"""
nvs = trav.shape[1]
# Create window
trav_off = trav - self.toff
trav_off = np.round(trav_off / self.dt).astype(int)
w = np.zeros((self.nr, nvs, self.nt), dtype=self.dtype)
for ir in range(self.nr):
for ivs in range(nvs):
w[ir, ivs, :trav_off[ir, ivs]] = 1
w = np.concatenate((np.flip(w, axis=-1), w[:, :, 1:]), axis=-1)
if self.nsmooth > 0:
smooth = np.ones(self.nsmooth, dtype=self.dtype) / self.nsmooth
w = filtfilt(smooth, 1, w)
w = to_cupy_conditional(self.Rtwosided_fft, w)
# Create operators
Rop = MDC(
self.Rtwosided_fft,
self.nt2,
nv=nvs,
dt=self.dt,
dr=self.dr,
twosided=True,
conj=False,
fftengine=self.fftengine,
transpose=False,
prescaled=self.prescaled,
usematmul=usematmul,
dtype=self.dtype,
)
R1op = MDC(
self.Rtwosided_fft,
self.nt2,
nv=nvs,
dt=self.dt,
dr=self.dr,
twosided=True,
conj=True,
fftengine=self.fftengine,
transpose=False,
prescaled=self.prescaled,
usematmul=usematmul,
dtype=self.dtype,
)
Rollop = Roll(
self.ns * nvs * self.nt2,
dims=(self.nt2, self.ns, nvs),
dir=0,
shift=-1,
dtype=self.dtype,
)
Wop = Diagonal(w.transpose(2, 0, 1).ravel())
Iop = Identity(self.nr * nvs * self.nt2)
Mop = Block([[Iop, -1 * Wop * Rop], [-1 * Wop * Rollop * R1op, Iop]
]) * BlockDiag([Wop, Wop])
Gop = Block([[Iop, -1 * Rop], [-1 * Rollop * R1op, Iop]])
if dottest:
Dottest(
Gop,
2 * self.nr * nvs * self.nt2,
2 * self.nr * nvs * self.nt2,
raiseerror=True,
verb=True,
backend=get_module_name(self.ncp),
)
if dottest:
Dottest(
Mop,
2 * self.ns * nvs * self.nt2,
2 * self.nr * nvs * self.nt2,
raiseerror=True,
verb=True,
backend=get_module_name(self.ncp),
)
# Create input focusing function
if G0 is None:
if self.wav is not None and nfft is not None:
G0 = np.zeros((self.nr, nvs, self.nt), dtype=self.dtype)
for ivs in range(nvs):
G0[:, ivs] = (directwave(
self.wav,
trav[:, ivs],
self.nt,
self.dt,
nfft=nfft,
derivative=True,
)).T
G0 = to_cupy_conditional(self.Rtwosided_fft, G0)
else:
logging.error("wav and/or nfft are not provided. "
"Provide either G0 or wav and nfft...")
raise ValueError("wav and/or nfft are not provided. "
"Provide either G0 or wav and nfft...")
fd_plus = np.concatenate((
np.flip(G0, axis=-1).transpose(2, 0, 1),
self.ncp.zeros((self.nt - 1, self.nr, nvs), dtype=self.dtype),
))
# Run standard redatuming as benchmark
if rtm:
p0_minus = Rop * fd_plus.ravel()
p0_minus = p0_minus.reshape(self.nt2, self.ns,
nvs).transpose(1, 2, 0)
# Create data and inverse focusing functions
d = Wop * Rop * fd_plus.ravel()
d = np.concatenate((
d.reshape(self.nt2, self.ns, nvs),
self.ncp.zeros((self.nt2, self.ns, nvs), dtype=self.dtype),
))
# Invert for focusing functions
if self.ncp == np:
f1_inv = lsqr(Mop, d.ravel(), **kwargs_solver)[0]
else:
f1_inv = cgls(Mop,
d.ravel(),
x0=self.ncp.zeros(2 * (2 * self.nt - 1) * self.nr *
nvs,
dtype=self.dtype),
**kwargs_solver)[0]
f1_inv = f1_inv.reshape(2 * self.nt2, self.nr, nvs)
f1_inv_tot = f1_inv + np.concatenate((self.ncp.zeros(
(self.nt2, self.nr, nvs), dtype=self.dtype), fd_plus))
f1_inv_minus = f1_inv_tot[:self.nt2].transpose(1, 2, 0)
f1_inv_plus = f1_inv_tot[self.nt2:].transpose(1, 2, 0)
if greens:
# Create Green's functions
g_inv = Gop * f1_inv_tot.ravel()
g_inv = g_inv.reshape(2 * self.nt2, self.ns, nvs)
g_inv_minus = -g_inv[:self.nt2].transpose(1, 2, 0)
g_inv_plus = np.flip(g_inv[self.nt2:], axis=0).transpose(1, 2, 0)
if rtm and greens:
return f1_inv_minus, f1_inv_plus, p0_minus, g_inv_minus, g_inv_plus
elif rtm:
return f1_inv_minus, f1_inv_plus, p0_minus
elif greens:
return f1_inv_minus, f1_inv_plus, g_inv_minus, g_inv_plus
else:
return f1_inv_minus, f1_inv_plus
class PdSmooth(object):
"""
A Reconstruction object to solve regularized inverse reconstruction problems.
Solver is Primal-Dual based.
Form:
1/2 * ||x - f||^2 + \alpha J(x)
J(x) regularisation term J in [TV(), || ||]
"""
def __init__(self,
domain_shape: np.ndarray,
reg_mode: str = '',
alpha=0.01,
tau: float = None):
self._reg_mode = None
self.domain_shape = domain_shape
self.alpha = alpha
self.tau = tau
self.reg_mode = reg_mode
self.solver = None
if type(alpha) is not float:
if self.alpha.shape == domain_shape:
self.alpha = Diagonal(self.alpha.ravel())
else:
msg = "shape of local parameter alpha does not match: "+ \
str(self.alpha.shape) + "!=" + str(domain_shape)
raise ValueError(msg)
@property
def reg_mode(self):
return self._reg_mode
@reg_mode.setter
def reg_mode(self, value):
if value in ['tikhonov', 'tv', None]:
self._reg_mode = value
else:
msg = "Please use reg_mode out of ['tikhonov', 'tv', '']"
raise ValueError(msg)
def solve(self,
data: np.ndarray,
maxiter: int = 150,
tol: float = 5 * 10**(-4)):
if self.reg_mode is not None:
grad = Gradient(dims=self.domain_shape,
edge=True,
dtype='float64',
kind='backward')
K = grad * self.alpha
if not self.tau:
norm = np.abs(np.asscalar(K.eigs(neigs=1, which='LM')))
sigma = 0.99 / norm
print(
"Calced tau: " + str(sigma) + ". "
"Next run with same alpha: set this tau value to decrease runtime."
)
tau = sigma
else:
tau = self.tau
sigma = tau
if self.reg_mode == 'tv':
F_star = Projection(self.domain_shape, len(self.domain_shape))
else:
F_star = DatatermLinear()
F_star.set_proxdata(0)
else:
tau = 0.99
sigma = tau
F_star = DatatermLinear()
K = 0
G = DatatermLinear()
G.set_proxparam(tau)
G.set_proxdata(data.ravel())
F_star.set_proxparam(sigma)
self.solver = PdHgm(K, F_star, G)
self.solver.maxiter = maxiter
self.solver.tol = tol
self.solver.solve()
return np.reshape(self.solver.var['x'], self.domain_shape)
def apply_onepoint(self,
trav,
G0=None,
nfft=None,
rtm=False,
greens=False,
dottest=False,
fast=True,
**kwargs_lsqr):
r"""Marchenko redatuming for one point
Solve the Marchenko redatuming inverse problem for a single point given its
direct arrival traveltime curve (``trav``) and waveform (``G0``).
Parameters
----------
trav : :obj:`numpy.ndarray`
Traveltime of first arrival from subsurface point to surface receivers
of size :math:`[n_r \times 1]`
G0 : :obj:`numpy.ndarray`, optional
Direct arrival in time domain of size :math:`[n_r \times n_t]`
(if None, create arrival using ``trav``)
nfft : :obj:`int`, optional
Number of samples in fft when creating the analytical direct wave
rtm : :obj:`bool`, optional
Compute and return rtm redatuming
greens : :obj:`bool`, optional
Compute and return Green's functions
dottest : :obj:`bool`, optional
Apply dot-test
fast : :obj:`bool`
Fast application of MDC when model has only one virtual source
(``True``) or not (``False``)
**kwargs_lsqr
Arbitrary keyword arguments for :py:func:`scipy.sparse.linalg.lsqr` solver
Returns
----------
f1_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing focusing function of size :math:`[n_r \times n_t]`
f1_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing focusing function of size :math:`[n_r \times n_t]`
p0_minus : :obj:`numpy.ndarray`
Single-scattering standard redatuming upgoing Green's function of
size :math:`[n_r \times n_t]`
g_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing Green's function of size :math:`[n_r \times n_t]`
g_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing Green's function of size :math:`[n_r \times n_t]`
"""
# Create window
trav_off = trav - self.toff
trav_off = np.round(trav_off / self.dt).astype(np.int)
# window
w = np.zeros((self.nr, self.nt))
for ir in range(self.nr):
w[ir, :trav_off[ir]] = 1
w = np.hstack((np.fliplr(w), w[:, 1:]))
if self.nsmooth > 0:
smooth = np.ones(self.nsmooth) / self.nsmooth
w = filtfilt(smooth, 1, w)
# Create operators
Rop = MDC(self.Rtwosided_fft,
self.nt2,
nv=1,
dt=self.dt,
dr=self.dr,
twosided=True,
fast=fast,
dtype=self.dtype)
R1op = MDC(self.R1twosided_fft,
self.nt2,
nv=1,
dt=self.dt,
dr=self.dr,
twosided=True,
fast=fast,
dtype=self.dtype)
Wop = Diagonal(w.flatten())
Iop = Identity(self.nr * (2 * self.nt - 1))
Mop = VStack(
[HStack([Iop, -1 * Wop * Rop]),
HStack([-1 * Wop * R1op, Iop])]) * BlockDiag([Wop, Wop])
Gop = VStack([HStack([Iop, -1 * Rop]), HStack([-1 * R1op, Iop])])
if dottest:
assert Dottest(Gop,
2 * self.nr * self.nt2,
2 * self.nr * self.nt2,
verb=True)
if dottest:
assert Dottest(Mop,
2 * self.nr * self.nt2,
2 * self.nr * self.nt2,
verb=True)
# Create input focusing function
if G0 is None:
if self.wav is not None and nfft is not None:
G0 = (directwave(self.wav, trav, self.nt, self.dt,
nfft=nfft)).T
else:
logging.error('wav and/or nfft are not provided. '
'Provide either G0 or wav and nfft...')
raise ValueError('wav and/or nfft are not provided. '
'Provide either G0 or wav and nfft...')
fd_plus = np.concatenate(
(np.fliplr(G0), np.zeros((self.nr, self.nt - 1))), axis=-1)
# Run standard redatuming as benchmark
if rtm:
p0_minus = Rop * fd_plus.flatten()
p0_minus = p0_minus.reshape(self.nr, self.nt2)
# Create data and inverse focusing functions
d = Wop * Rop * fd_plus.flatten()
d = np.concatenate(
(d.reshape(self.nr, self.nt2), np.zeros((self.nr, self.nt2))))
f1_inv = lsqr(Mop, d.flatten(), **kwargs_lsqr)[0]
f1_inv = f1_inv.reshape(2 * self.nr, self.nt2)
f1_inv_tot = f1_inv + np.concatenate((np.zeros(
(self.nr, self.nt2)), fd_plus))
f1_inv_minus, f1_inv_plus = f1_inv_tot[:self.nr], f1_inv_tot[self.nr:]
if greens:
# Create Green's functions
g_inv = Gop * f1_inv_tot.flatten()
g_inv = g_inv.reshape(2 * self.nr, (2 * self.nt - 1))
g_inv_minus, g_inv_plus = -g_inv[:self.nr], np.fliplr(
g_inv[self.nr:])
if rtm and greens:
return f1_inv_minus, f1_inv_plus, p0_minus, g_inv_minus, g_inv_plus
elif rtm:
return f1_inv_minus, f1_inv_plus, p0_minus
elif greens:
return f1_inv_minus, f1_inv_plus, g_inv_minus, g_inv_plus
else:
return f1_inv_minus, f1_inv_plus
def MDD(G,
d,
dt=0.004,
dr=1.,
nfmax=None,
wav=None,
twosided=True,
causality_precond=False,
adjoint=False,
psf=False,
dtype='complex64',
dottest=False,
**kwargs_lsqr):
r"""Multi-dimensional deconvolution.
Solve multi-dimensional deconvolution problem using :py:func:`scipy.sparse.linalg.lsqr`
iterative solver.
Parameters
----------
G : :obj:`numpy.ndarray`
Multi-dimensional convolution kernel in frequency domain of size
:math:`[n_s \times n_r \times n_{fmax}]`
d : :obj:`numpy.ndarray`
Data in time domain :math:`[ns (\times nr) \times nt]`
dt : :obj:`float`, optional
Sampling of time integration axis
dr : :obj:`float`, optional
Sampling of receiver integration axis
nfmax : :obj:`int`, optional
Index of max frequency to include in deconvolution process
twosided : :obj:`bool`, optional
MDC operator has both negative and positive time (``True``)
or only positive (``False``)
causality_precond : :obj:`bool`, optional
Apply causality mask (``True``) or not (``False``)
adjoint : :obj:`bool`, optional
Compute and return adjoint(s)
psf : :obj:`bool`, optional
Compute and return Point Spread Function (PSF) and its inverse
dtype : :obj:`bool`, optional
Type of elements in input array.
dottest : :obj:`bool`, optional
Apply dot-test
**kwargs_lsqr
Arbitrary keyword arguments for :py:func:`scipy.sparse.linalg.lsqr` solver
Returns
----------
minv : :obj:`numpy.ndarray`
Inverted model.
madj : :obj:`numpy.ndarray`
Adjoint model.
psfinv : :obj:`numpy.ndarray`
Inverted psf.
psfadj : :obj:`numpy.ndarray`
Adjoint psf.
See Also
--------
MDC : Multi-dimensional convolution
Notes
-----
Multi-dimensional deconvolution (MDD) is a mathematical ill-solved problem,
well-known in the image processing and geophysical community [1]_.
MDD aims at removing the effects of a Multi-dimensional Convolution (MDC) kernel
or the so-called blurring operator or point-spread function (PSF) from a given data.
It can be written as
.. math::
\mathbf{d}= \mathbf{D} \mathbf{m}
or, equivalently, by means of its normal equation
.. math::
\mathbf{m}= (\mathbf{D}^H\mathbf{D})^{-1} \mathbf{D}^H\mathbf{d}
where :math:`\mathbf{D}^H\mathbf{D}` is the PSF.
.. [1] Wapenaar, K., van der Neut, J., Ruigrok, E., Draganov, D., Hunziker, J.,
Slob, E., Thorbecke, J., and Snieder, R., "Seismic interferometry by crosscorrelation
and by multi-dimensional deconvolution: a systematic comparison",
Geophyscial Journal International, vol. 185, pp. 1335-1364. 2011.
"""
ns, nr, nt = G.shape
if len(d.shape) == 2:
ns, nt = d.shape
nv = 1
else:
ns, nv, nt = d.shape
nt2 = nt if twosided == False else 2 * nt - 1
# Fix nfmax to be at maximum equal to half of the size of fft samples
if nfmax == None or nfmax > np.ceil((nt2 + 1) / 2):
nfmax = int(np.ceil((nt2 + 1) / 2))
logging.warning('nfmax set equal to (nt+1)/2=%d' % nfmax)
# Add negative part to data and model
if twosided:
G = np.concatenate((np.zeros((ns, nr, nt - 1)), G), axis=-1)
d = np.concatenate((np.squeeze(np.zeros((ns, nv, nt - 1))), d),
axis=-1)
# Define MDC linear operator
Gfft = np.fft.rfft(G, nt2, axis=-1)
Gfft = Gfft[..., :nfmax]
MDCop = MDC(Gfft, nt2, nv=nv, dt=dt, dr=dr, twosided=twosided, dtype=dtype)
if psf:
PSFop = MDC(Gfft,
nt2,
nv=nr,
dt=dt,
dr=dr,
twosided=twosided,
dtype=dtype)
if dottest:
Dottest(MDCop, nt2 * ns * nv, nt2 * nr * nv, verb=True)
if psf:
Dottest(PSFop, nt2 * ns * nr, nt2 * nr * nr, verb=True)
# Adjoint
if adjoint:
madj = MDCop.H * d.flatten()
madj = np.squeeze(madj.reshape(nr, nv, nt2))
if psf:
psfadj = PSFop.H * G.flatten()
psfadj = np.squeeze(psfadj.reshape(nr, nr, nt2))
# Inverse
if twosided and causality_precond:
P = np.ones((nr, nv, nt2))
P[:, :, :nt - 1] = 0
Pop = Diagonal(P)
minv = PreconditionedInversion(MDCop,
Pop,
d.flatten(),
returninfo=False,
**kwargs_lsqr)
else:
minv = lsqr(MDCop, d.flatten(), **kwargs_lsqr)[0]
minv = np.squeeze(minv.reshape(nr, nv, nt2))
if wav is not None:
minv = sp_convolve1d(minv, wav, axis=-1)
if psf:
psfinv = lsqr(PSFop, G.flatten(), **kwargs_lsqr)[0]
psfinv = np.squeeze(psfinv.reshape(nr, nr, nt2))
if wav is not None:
psfinv = sp_convolve1d(psfinv, wav, axis=-1)
if adjoint and psf:
return minv, madj, psfinv, psfadj
elif adjoint:
return minv, madj
elif psf:
return minv, psfinv
else:
return minv
def apply_onepoint(self,
trav,
G0=None,
nfft=None,
rtm=False,
greens=False,
dottest=False,
fast=None,
**kwargs_solver):
r"""Marchenko redatuming for one point
Solve the Marchenko redatuming inverse problem for a single point
given its direct arrival traveltime curve (``trav``)
and waveform (``G0``).
Parameters
----------
trav : :obj:`numpy.ndarray`
Traveltime of first arrival from subsurface point to
surface receivers of size :math:`[n_r \times 1]`
G0 : :obj:`numpy.ndarray`, optional
Direct arrival in time domain of size :math:`[n_r \times n_t]`
(if None, create arrival using ``trav``)
nfft : :obj:`int`, optional
Number of samples in fft when creating the analytical direct wave
rtm : :obj:`bool`, optional
Compute and return rtm redatuming
greens : :obj:`bool`, optional
Compute and return Green's functions
dottest : :obj:`bool`, optional
Apply dot-test
fast : :obj:`bool`
*Deprecated*, will be removed in v2.0.0
**kwargs_solver
Arbitrary keyword arguments for chosen solver
(:py:func:`scipy.sparse.linalg.lsqr` and
:py:func:`pylops.optimization.solver.cgls` are used as default
for numpy and cupy `data`, respectively)
Returns
----------
f1_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing focusing function of size :math:`[n_r \times n_t]`
f1_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing focusing function
of size :math:`[n_r \times n_t]`
p0_minus : :obj:`numpy.ndarray`
Single-scattering standard redatuming upgoing Green's function of
size :math:`[n_r \times n_t]`
g_inv_minus : :obj:`numpy.ndarray`
Inverted upgoing Green's function of size :math:`[n_r \times n_t]`
g_inv_plus : :obj:`numpy.ndarray`
Inverted downgoing Green's function
of size :math:`[n_r \times n_t]`
"""
# Create window
trav_off = trav - self.toff
trav_off = np.round(trav_off / self.dt).astype(np.int)
w = np.zeros((self.nr, self.nt), dtype=self.dtype)
for ir in range(self.nr):
w[ir, :trav_off[ir]] = 1
w = np.hstack((np.fliplr(w), w[:, 1:]))
if self.nsmooth > 0:
smooth = np.ones(self.nsmooth, dtype=self.dtype) / self.nsmooth
w = filtfilt(smooth, 1, w)
w = to_cupy_conditional(self.Rtwosided_fft, w)
# Create operators
Rop = MDC(self.Rtwosided_fft,
self.nt2,
nv=1,
dt=self.dt,
dr=self.dr,
twosided=True,
conj=False,
transpose=False,
saveGt=self.saveRt,
prescaled=self.prescaled,
dtype=self.dtype)
R1op = MDC(self.Rtwosided_fft,
self.nt2,
nv=1,
dt=self.dt,
dr=self.dr,
twosided=True,
conj=True,
transpose=False,
saveGt=self.saveRt,
prescaled=self.prescaled,
dtype=self.dtype)
Rollop = Roll(self.nt2 * self.ns,
dims=(self.nt2, self.ns),
dir=0,
shift=-1,
dtype=self.dtype)
Wop = Diagonal(w.T.flatten())
Iop = Identity(self.nr * self.nt2)
Mop = Block([[Iop, -1 * Wop * Rop], [-1 * Wop * Rollop * R1op, Iop]
]) * BlockDiag([Wop, Wop])
Gop = Block([[Iop, -1 * Rop], [-1 * Rollop * R1op, Iop]])
if dottest:
Dottest(Gop,
2 * self.ns * self.nt2,
2 * self.nr * self.nt2,
raiseerror=True,
verb=True,
backend=get_module_name(self.ncp))
if dottest:
Dottest(Mop,
2 * self.ns * self.nt2,
2 * self.nr * self.nt2,
raiseerror=True,
verb=True,
backend=get_module_name(self.ncp))
# Create input focusing function
if G0 is None:
if self.wav is not None and nfft is not None:
G0 = (directwave(self.wav,
trav,
self.nt,
self.dt,
nfft=nfft,
derivative=True)).T
G0 = to_cupy_conditional(self.Rtwosided_fft, G0)
else:
logging.error('wav and/or nfft are not provided. '
'Provide either G0 or wav and nfft...')
raise ValueError('wav and/or nfft are not provided. '
'Provide either G0 or wav and nfft...')
fd_plus = np.concatenate((np.fliplr(G0).T,
self.ncp.zeros((self.nt - 1, self.nr),
dtype=self.dtype)))
# Run standard redatuming as benchmark
if rtm:
p0_minus = Rop * fd_plus.flatten()
p0_minus = p0_minus.reshape(self.nt2, self.ns).T
# Create data and inverse focusing functions
d = Wop * Rop * fd_plus.flatten()
d = np.concatenate((d.reshape(self.nt2, self.ns),
self.ncp.zeros((self.nt2, self.ns), self.dtype)))
# Invert for focusing functions
if self.ncp == np:
f1_inv = lsqr(Mop, d.flatten(), **kwargs_solver)[0]
else:
f1_inv = cgls(Mop,
d.flatten(),
x0=self.ncp.zeros(2 * (2 * self.nt - 1) * self.nr,
dtype=self.dtype),
**kwargs_solver)[0]
f1_inv = f1_inv.reshape(2 * self.nt2, self.nr)
f1_inv_tot = f1_inv + np.concatenate((self.ncp.zeros(
(self.nt2, self.nr), dtype=self.dtype), fd_plus))
f1_inv_minus = f1_inv_tot[:self.nt2].T
f1_inv_plus = f1_inv_tot[self.nt2:].T
if greens:
# Create Green's functions
g_inv = Gop * f1_inv_tot.flatten()
g_inv = g_inv.reshape(2 * self.nt2, self.ns)
g_inv_minus, g_inv_plus = -g_inv[:self.nt2].T, \
np.fliplr(g_inv[self.nt2:].T)
if rtm and greens:
return f1_inv_minus, f1_inv_plus, p0_minus, g_inv_minus, g_inv_plus
elif rtm:
return f1_inv_minus, f1_inv_plus, p0_minus
elif greens:
return f1_inv_minus, f1_inv_plus, g_inv_minus, g_inv_plus
else:
return f1_inv_minus, f1_inv_plus
def _obliquity3D(
nt,
nr,
dt,
dr,
rho,
vel,
nffts,
critical=100.0,
ntaper=10,
composition=True,
backend="numpy",
dtype="complex128",
):
r"""3D Obliquity operator and FFT operator
Parameters
----------
nt : :obj:`int`
Number of samples along the time axis
nr : :obj:`tuple`
Number of samples along the receiver axes
dt : :obj:`float`
Sampling along the time axis
dr : :obj:`tuple`
Samplings along the receiver array
rho : :obj:`float`
Density along the receiver array (must be constant)
vel : :obj:`float`
Velocity along the receiver array (must be constant)
nffts : :obj:`tuple`, optional
Number of samples along the wavenumber and frequency axes
critical : :obj:`float`, optional
Percentage of angles to retain in obliquity factor. For example, if
``critical=100`` only angles below the critical angle
:math:`\sqrt{k_y^2 + k_x^2} < \frac{\omega}{vel}` will be retained
ntaper : :obj:`float`, optional
Number of samples of taper applied to obliquity factor around critical
angle
composition : :obj:`bool`, optional
Create obliquity factor for composition (``True``) or
decomposition (``False``)
backend : :obj:`str`, optional
Backend used for creation of obliquity factor operator
(``numpy`` or ``cupy``)
dtype : :obj:`str`, optional
Type of elements in input array.
Returns
-------
FFTop : :obj:`pylops.LinearOperator`
FFT operator
OBLop : :obj:`pylops.LinearOperator`
Obliquity factor operator
"""
# create Fourier operator
FFTop = FFTND(dims=[nr[0], nr[1], nt],
nffts=nffts,
sampling=[dr[0], dr[1], dt],
dtype=dtype)
# create obliquity operator
[Ky, Kx, F] = np.meshgrid(FFTop.fs[0],
FFTop.fs[1],
FFTop.fs[2],
indexing="ij")
k = F / vel
Kz = np.sqrt((k**2 - Ky**2 - Kx**2).astype(dtype))
Kz[np.isnan(Kz)] = 0
if composition:
OBL = Kz / (rho * np.abs(F))
OBL[F == 0] = 0
else:
OBL = rho * (np.abs(F) / Kz)
OBL[Kz == 0] = 0
# cut off and taper
OBL = _filter_obliquity(OBL, F, Kx, vel, critical, ntaper, Ky=Ky)
OBL = get_module(backend).asarray(OBL)
OBLop = Diagonal(OBL.ravel(), dtype=dtype)
return FFTop, OBLop
