pylops_distributed.waveeqprocessing.Marchenko

class pylops_distributed.waveeqprocessing.Marchenko(R, nt, dt=0.004, dr=1.0, wav=None, toff=0.0, nsmooth=10, saveRt=False, prescaled=False, dtype='float32')[source]

Marchenko redatuming

Solve multi-dimensional Marchenko redatuming problem using scipy.sparse.linalg.lsqr iterative solver.

Parameters:
R : dask.array

Multi-dimensional reflection response in frequency domain of size \([n_{fmax} \times n_s \times n_r]\). Note that the reflection response should have already been multiplied by 2.

nt : float, optional

Number of samples in time

dt : float, optional

Sampling of time integration axis

dr : float, optional

Sampling of receiver integration axis

wav : numpy.ndarray, optional

Wavelet to apply to direct arrival when created using trav

toff : float, optional

Time-offset to apply to traveltime

nsmooth : int, optional

Number of samples of smoothing operator to apply to window

saveRt : bool, optional

Save R and R^H to speed up the computation of the adjoint of pylops_distributed.signalprocessing.Fredholm1 (True) or create R^H on-the-fly (False) Note that saveRt=True will be faster but double the amount of required memory

prescaled : bool, optional

Apply scaling to R (False) or not (False) when performing spatial and temporal summations within the pylops.waveeqprocessing.MDC operator. In case prescaled=True, the R is assumed to have been pre-scaled by the user.

dtype : bool, optional

Type of elements in input array.
Raises:
TypeError

If t is not numpy.ndarray.

See also

MDC
Multi-dimensional convolution

Notes

Refer to pylops.waveeqprocessing.Marchenko for implementation details.

Attributes:
ns : int

Number of samples along source axis

nr : int

Number of samples along receiver axis

shape : tuple

Operator shape

explicit : bool

Operator contains a matrix that can be solved explicitly (True) or not (False)

Methods

__init__(R, nt[, dt, dr, wav, toff, …]) Initialize self.
apply_multiplepoints(trav[, dist, G0, nfft, …]) Marchenko redatuming for multiple points
apply_onepoint(trav[, dist, G0, nfft, rtm, …]) Marchenko redatuming for one point
apply_onepoint(trav, dist=None, G0=None, nfft=None, rtm=False, greens=False, dottest=False, **kwargs_cgls)[source]

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 : numpy.ndarray

Traveltime of first arrival from subsurface point to surface receivers of size \([n_r \times 1]\)

dist: :obj:`numpy.ndarray`, optional

Distance between subsurface point to surface receivers of size \(\lbrack nr \times 1 \rbrack\) (if provided the analytical direct arrival will be computed using a 3d formulation)

G0 : numpy.ndarray, optional

Direct arrival in time domain of size \([n_r \times n_t]\) (if None, create arrival using trav)

nfft : int, optional

Number of samples in fft when creating the analytical direct wave

rtm : bool, optional

Compute and return rtm redatuming

greens : bool, optional

Compute and return Green’s functions

dottest : bool, optional

Apply dot-test

**kwargs_cgls

Arbitrary keyword arguments for pylops_distributed.optimization.cg.cgls solver
Returns:
f1_inv_minus : dask.array

Inverted upgoing focusing function of size \([n_r \times n_t]\)

f1_inv_plus : dask.array

Inverted downgoing focusing function of size \([n_r \times n_t]\)

p0_minus : dask.array

Single-scattering standard redatuming upgoing Green’s function of size \([n_r \times n_t]\)

g_inv_minus : dask.array

Inverted upgoing Green’s function of size \([n_r \times n_t]\)

g_inv_plus : dask.array

Inverted downgoing Green’s function of size \([n_r \times n_t]\)
apply_multiplepoints(trav, dist=None, G0=None, nfft=None, rtm=False, greens=False, dottest=False, **kwargs_cgls)[source]

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 : numpy.ndarray

Traveltime of first arrival from subsurface points to surface receivers of size \([n_r \times n_{vs}]\)

dist: :obj:`numpy.ndarray`, optional

Distance between subsurface point to surface receivers of size \([n_r \times n_{vs}]\) (if provided the analytical direct arrival will be computed using a 3d formulation)

G0 : numpy.ndarray, optional

Direct arrival in time domain of size \([n_r \times n_{vs} \times n_t]\) (if None, create arrival using trav)

nfft : int, optional

Number of samples in fft when creating the analytical direct wave

rtm : bool, optional

Compute and return rtm redatuming

greens : bool, optional

Compute and return Green’s functions

dottest : bool, optional

Apply dot-test

**kwargs_cgls

Arbitrary keyword arguments for pylops_distributed.optimization.cg.cgls solver
Returns:
f1_inv_minus : numpy.ndarray

Inverted upgoing focusing function of size \([n_r \times n_{vs} \times n_t]\)

f1_inv_plus : numpy.ndarray

Inverted downgoing focusing functionof size \([n_r \times n_{vs} \times n_t]\)

p0_minus : numpy.ndarray

Single-scattering standard redatuming upgoing Green’s function of size \([n_r \times n_{vs} \times n_t]\)

g_inv_minus : numpy.ndarray

Inverted upgoing Green’s function of size \([n_r \times n_{vs} \times n_t]\)

g_inv_plus : numpy.ndarray

Inverted downgoing Green’s function of size \([n_r \times n_{vs} \times n_t]\)

Examples using pylops_distributed.waveeqprocessing.Marchenko