pylops.signalprocessing.FourierRadon2D#

class pylops.signalprocessing.FourierRadon2D(taxis, haxis, pxaxis, nfft, flims=None, kind='linear', engine='numpy', num_threads_per_blocks=(32, 32), dtype='float64', name='R')[source]#

2D Fourier Radon transform

Apply Radon forward (and adjoint) transform using Fast Fourier Transform to a 2-dimensional array of size \([n_{p_x} \times n_t]\) (and \([n_x \times n_t]\)).

Note that forward and adjoint follow the same convention of the time-space implementation in pylops.signalprocessing.Radon2D.

Parameters
taxisnp.ndarray

Time axis

haxisnp.ndarray

Spatial axis

pxaxisnp.ndarray

Axis of scanning variable \(p_x\) of parametric curve

nfftint

Number of samples in Fourier transform

flimstuple, optional

Indices of lower and upper limits of Fourier axis to be used in the application of the Radon matrix (when None, use entire axis)

kindstr

Curve to be used for stacking/spreading (linear, parabolic)

enginestr

Engine used for computation (numpy or numba or cuda)

num_threads_per_blockstuple

Number of threads in each block (only when engine=cuda)

dtypestr

Type of elements in input array.

namestr

Name of operator (to be used by pylops.utils.describe.describe)

Raises
NotImplementedError

If engine is neither numpy, numba, nor cuda.

Notes

The FourierRadon2D operator applies the Radon transform in the frequency domain. After transforming a 2-dimensional array of size \([n_x \times n_t]\) into the frequency domain, the following linear transformation is applied to each frequency component in adjoint mode:

\[\begin{split}\begin{bmatrix} m(p_{x,1}, \omega_i) \\ m(p_{x,2}, \omega_i) \\ \vdots \\ m(p_{x,N_p}, \omega_i) \end{bmatrix} = \begin{bmatrix} e^{-j \omega_i p_{x,1} x^l_1} & e^{-j \omega_i p_{x,1} x^l_2} & \ldots & e^{-j \omega_i p_{x,1} x^l_{N_x}} \\ e^{-j \omega_i p_{x,2} x^l_1} & e^{-j \omega_i p_{x,2} x^l_2} & \ldots & e^{-j \omega_i p_{x,2} x^l_{N_x}} \\ \vdots & \vdots & \ddots & \vdots \\ e^{-j \omega_i p_{x,N_p} x^l_1} & e^{-j \omega_i p_{x,N_p} x^l_2} & \ldots & e^{-j \omega_i p_{x,N_p} x^l_{N_x}} \\ \end{bmatrix} \begin{bmatrix} d(x_1, \omega_i) \\ d(x_2, \omega_i) \\ \vdots \\ d(x_{N_x}, \omega_i) \end{bmatrix}\end{split}\]

where \(l=1,2\). Similarly the forward mode is implemented by applying the transpose and complex conjugate of the above matrix to the model transformed to the Fourier domain.

Refer to [1] for more theoretical and implementation details.

1

Sacchi, M. “Statistical and Transform Methods for Geophysical Signal Processing”, 2007.

Attributes
shapetuple

Operator shape

explicitbool

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

Methods

__init__(taxis, haxis, pxaxis, nfft[, ...])

adjoint()

apply_columns(cols)

Apply subset of columns of operator

cond([uselobpcg])

Condition number of linear operator.

conj()

Complex conjugate operator

div(y[, niter, densesolver])

Solve the linear problem \(\mathbf{y}=\mathbf{A}\mathbf{x}\).

dot(x)

Matrix-matrix or matrix-vector multiplication.

eigs([neigs, symmetric, niter, uselobpcg])

Most significant eigenvalues of linear operator.

matmat(X)

Matrix-matrix multiplication.

matvec(x)

Matrix-vector multiplication.

reset_count()

Reset counters

rmatmat(X)

Matrix-matrix multiplication.

rmatvec(x)

Adjoint matrix-vector multiplication.

todense([backend])

Return dense matrix.

toimag([forw, adj])

Imag operator

toreal([forw, adj])

Real operator

tosparse()

Return sparse matrix.

trace([neval, method, backend])

Trace of linear operator.

transpose()

Examples using pylops.signalprocessing.FourierRadon2D#

Fourier Radon Transform

Fourier Radon Transform