def test_zoeppritz_and_approx_multipleangles():
"""Validate zoeppritz and approximations for set of angles from 0 to 40 degress
"""
# Create composite parameters
ai0, si0 = vp0 * rho0, vs0 * rho0
ai1, si1 = vp1 * rho1, vs1 * rho1
# Zoeppritz
rpp_zoep = zoeppritz_pp(vp1, vs1, rho1, vp0, vs0, rho0, theta)
rpp_zoep_approx = approx_zoeppritz_pp(vp1, vs1, rho1, vp0, vs0, rho0,
theta)
# Aki Richards
rvp = np.log(vp0) - np.log(vp1)
rvs = np.log(vs0) - np.log(vs1)
rrho = np.log(rho0) - np.log(rho1)
G1, G2, G3 = akirichards(theta, vs1 / vp1)
rpp_aki = G1 * rvp + G2 * rvs + G3 * rrho
# Fatti
rai = np.log(ai0) - np.log(ai1)
rsi = np.log(si0) - np.log(si1)
G1, G2, G3 = fatti(theta, vs1 / vp1)
rpp_fatti = G1 * rai + G2 * rsi + G3 * rrho
assert_array_almost_equal(rpp_zoep, rpp_zoep_approx, decimal=3)
assert_array_almost_equal(rpp_zoep, rpp_aki, decimal=3)
assert_array_almost_equal(rpp_zoep, rpp_fatti, decimal=3)
def test_zoeppritz_and_approx_zeroangle():
"""Validate zoeppritz and approximations at zero incident angle
"""
#Create composite parameters
ai0, si0, vpvs0 = vp0 * rho0, vs0 * rho0, vp0 / vs0
ai1, si1, vpvs1 = vp1 * rho1, vs1 * rho1, vp1 / vs1
# Zoeppritz
rpp_zoep = zoeppritz_pp(vp1, vs1, rho1, vp0, vs0, rho0, theta[0])
rpp_zoep_approx = approx_zoeppritz_pp(vp1, vs1, rho1, vp0, vs0, rho0,
theta[0])
# Aki Richards
rvp = np.log(vp0) - np.log(vp1)
rvs = np.log(vs0) - np.log(vs1)
rrho = np.log(rho0) - np.log(rho1)
G1, G2, G3 = akirichards(theta[0], vs1 / vp1)
rpp_aki = G1 * rvp + G2 * rvs + G3 * rrho
# Fatti
rai = np.log(ai0) - np.log(ai1)
rsi = np.log(si0) - np.log(si1)
G1, G2, G3 = fatti(theta[0], vs1 / vp1)
rpp_fatti = G1 * rai + G2 * rsi + G3 * rrho
assert_array_almost_equal(rpp_zoep, rpp_zoep_approx, decimal=3)
assert_array_almost_equal(rpp_zoep, rpp_aki, decimal=3)
assert_array_almost_equal(rpp_zoep, rpp_fatti, decimal=3)
def PrestackLinearModelling(wav,
theta,
vsvp=0.5,
nt0=1,
spatdims=None,
linearization='akirich',
explicit=False,
kind='centered'):
r"""Pre-stack linearized seismic modelling operator.
Create operator to be applied to elastic property profiles
for generation of band-limited seismic angle gathers from a
linearized version of the Zoeppritz equation. The input model must
be arranged in a vector of size :math:`n_m \times n_{t0} (\times n_x \times n_y)`
for ``explicit=True`` and :math:`n_{t0} \times n_m (\times n_x \times n_y)`
for ``explicit=False``. Similarly the output data is arranged in a
vector of size :math:`n_{theta} \times n_{t0} (\times n_x \times n_y)`
for ``explicit=True`` and :math:`n_{t0} \times n_{theta} (\times n_x \times n_y)`
for ``explicit=False``.
Parameters
----------
wav : :obj:`np.ndarray`
Wavelet in time domain (must had odd number of
elements and centered to zero). Note that the ``dtype`` of this
variable will define that of the operator
theta : :obj:`np.ndarray`
Incident angles in degrees. Must have same ``dtype`` of ``wav`` (or
it will be automatically casted to it)
vsvp : :obj:`float` or :obj:`np.ndarray`
VS/VP ratio (constant or time/depth variant)
nt0 : :obj:`int`, optional
number of samples (if ``vsvp`` is a scalar)
spatdims : :obj:`int` or :obj:`tuple`, optional
Number of samples along spatial axis (or axes)
(``None`` if only one dimension is available)
linearization : :obj:`str` or :obj:`func`, optional
choice of linearization, ``akirich``: Aki-Richards, ``fatti``: Fatti,
``ps``: PS or any function on the form of
``pylops.avo.avo.akirichards``
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)
kind : :obj:`str`, optional
Derivative kind (``forward`` or ``centered``).
Returns
-------
Preop : :obj:`LinearOperator`
pre-stack modelling operator.
Raises
------
NotImplementedError
If ``linearization`` is not an implemented linearization
NotImplementedError
If ``kind`` is not ``forward`` nor ``centered``
Notes
-----
Pre-stack seismic modelling is the process of constructing seismic
pre-stack data from three (or two) profiles of elastic parameters in time
(or depth) domain. This can be easily achieved using the following
forward model:
.. math::
d(t, \theta) = w(t) * \sum_{i=1}^{n_m} G_i(t, \theta) m_i(t)
where :math:`w(t)` is the time domain seismic wavelet. In compact form:
.. math::
\mathbf{d}= \mathbf{G} \mathbf{m}
On the other hand, pre-stack inversion aims at recovering the different
profiles of elastic properties from the band-limited seismic
pre-stack data.
"""
ncp = get_array_module(wav)
# check kind is correctly selected
if kind not in ['forward', 'centered']:
raise NotImplementedError('%s not an available derivative kind...' %
kind)
# define dtype to be used
dtype = theta.dtype # ensure theta.dtype rules that of operator
theta = theta.astype(dtype)
# create vsvp profile
vsvp = vsvp if isinstance(vsvp, ncp.ndarray) else \
vsvp * ncp.ones(nt0, dtype=dtype)
nt0 = len(vsvp)
ntheta = len(theta)
# organize dimensions
if spatdims is None:
dims = (nt0, ntheta)
spatdims = None
elif isinstance(spatdims, int):
dims = (nt0, ntheta, spatdims)
spatdims = (spatdims, )
else:
dims = (nt0, ntheta) + spatdims
if explicit:
# Create AVO operator
if linearization == 'akirich':
G = akirichards(theta, vsvp, n=nt0)
elif linearization == 'fatti':
G = fatti(theta, vsvp, n=nt0)
elif linearization == 'ps':
G = ps(theta, vsvp, n=nt0)
elif callable(linearization):
G = linearization(theta, vsvp, n=nt0)
else:
logging.error('%s not an available linearization...',
linearization)
raise NotImplementedError('%s not an available linearization...' %
linearization)
nG = len(G)
G = [
ncp.hstack([
ncp.diag(G_[itheta] * ncp.ones(nt0, dtype=dtype)) for G_ in G
]) for itheta in range(ntheta)
]
G = ncp.vstack(G).reshape(ntheta * nt0, nG * nt0)
# Create derivative operator
if kind == 'centered':
D = ncp.diag(0.5 * ncp.ones(nt0 - 1, dtype=dtype), k=1) - \
ncp.diag(0.5 * ncp.ones(nt0 - 1, dtype=dtype), k=-1)
D[0] = D[-1] = 0
else:
D = ncp.diag(ncp.ones(nt0 - 1, dtype=dtype), k=1) - \
ncp.diag(ncp.ones(nt0, dtype=dtype), k=0)
D[-1] = 0
D = get_block_diag(theta)(*([D] * nG))
# Create wavelet operator
C = convmtx(wav, nt0)[:, len(wav) // 2:-len(wav) // 2 + 1]
C = [C] * ntheta
C = get_block_diag(theta)(*C)
# Combine operators
M = ncp.dot(C, ncp.dot(G, D))
Preop = MatrixMult(M, dims=spatdims, dtype=dtype)
else:
# Create wavelet operator
Cop = Convolve1D(np.prod(np.array(dims)),
h=wav,
offset=len(wav) // 2,
dir=0,
dims=dims,
dtype=dtype)
# create AVO operator
AVOop = AVOLinearModelling(theta,
vsvp,
spatdims=spatdims,
linearization=linearization,
dtype=dtype)
# Create derivative operator
dimsm = list(dims)
dimsm[1] = AVOop.npars
Dop = FirstDerivative(np.prod(np.array(dimsm)),
dims=dimsm,
dir=0,
sampling=1.,
kind=kind,
dtype=dtype)
Preop = Cop * AVOop * Dop
return Preop
def PrestackWaveletModelling(m,
theta,
nwav,
wavc=None,
vsvp=0.5,
linearization='akirich'):
r"""Pre-stack linearized seismic modelling operator for wavelet.
Create operator to be applied to a wavelet for generation of
band-limited seismic angle gathers using a linearized version
of the Zoeppritz equation.
Parameters
----------
m : :obj:`np.ndarray`
elastic parameter profles of size :math:`[n_{t0} \times N]`
where :math:`N=3/2`. Note that the ``dtype`` of this
variable will define that of the operator
theta : :obj:`int`
Incident angles in degrees. Must have same ``dtype`` of ``m`` (or
it will be automatically casted to it)
nwav : :obj:`np.ndarray`
Number of samples of wavelet to be applied/estimated
wavc : :obj:`int`, optional
Index of the center of the wavelet
vsvp : :obj:`np.ndarray` or :obj:`float`, optional
VS/VP ratio
linearization : :obj:`str`, optional
choice of linearization, ``akirich``: Aki-Richards,
``fatti``: Fatti, ``ps``: PS, or any function on the form of
``pylops.avo.avo.akirichards``
Returns
-------
Mconv : :obj:`LinearOperator`
pre-stack modelling operator for wavelet estimation.
Raises
------
NotImplementedError
If ``linearization`` is not an implemented linearization
Notes
-----
Pre-stack seismic modelling for wavelet estimate is the process
of constructing seismic reflectivities using three (or two)
profiles of elastic parameters in time (or depth)
domain arranged in an input vector :math:`\mathbf{m}`
of size :math:`nt0 \times N`:
.. math::
d(t, \theta) = \sum_{i=1}^N G_i(t, \theta) m_i(t) * w(t)
where :math:`w(t)` is the time domain seismic wavelet. In compact form:
.. math::
\mathbf{d}= \mathbf{G} \mathbf{w}
On the other hand, pre-stack wavelet estimation aims at
recovering the wavelet given knowledge of the band-limited
seismic pre-stack data and the elastic parameter profiles.
"""
ncp = get_array_module(theta)
# define dtype to be used
dtype = m.dtype # ensure m.dtype rules that of operator
theta = theta.astype(dtype)
# Create vsvp profile
vsvp = vsvp if isinstance(vsvp, ncp.ndarray) else \
vsvp * ncp.ones(m.shape[0], dtype=dtype)
wavc = nwav // 2 if wavc is None else wavc
nt0 = len(vsvp)
ntheta = len(theta)
# Create AVO operator
if linearization == 'akirich':
G = akirichards(theta, vsvp, n=nt0)
elif linearization == 'fatti':
G = fatti(theta, vsvp, n=nt0)
elif linearization == 'ps':
G = ps(theta, vsvp, n=nt0)
elif callable(linearization):
G = linearization(theta, vsvp, n=nt0)
else:
logging.error('%s not an available linearization...', linearization)
raise NotImplementedError('%s not an available linearization...' %
linearization)
nG = len(G)
G = [
ncp.hstack(
[ncp.diag(G_[itheta] * ncp.ones(nt0, dtype=dtype)) for G_ in G])
for itheta in range(ntheta)
]
G = ncp.vstack(G).reshape(ntheta * nt0, nG * nt0)
# Create derivative operator
D = ncp.diag(0.5 * np.ones(nt0 - 1, dtype=dtype), k=1) - \
ncp.diag(0.5 * np.ones(nt0 - 1, dtype=dtype), k=-1)
D[0] = D[-1] = 0
D = get_block_diag(theta)(*([D] * nG))
# Create infinite-reflectivity data
M = ncp.dot(G, ncp.dot(D, m.T.flatten())).reshape(ntheta, nt0)
Mconv = VStack([
MatrixMult(convmtx(M[itheta], nwav)[wavc:-nwav + wavc + 1],
dtype=dtype) for itheta in range(ntheta)
])
return Mconv
def PrestackLinearModelling(wav,
theta,
vsvp=0.5,
nt0=1,
spatdims=None,
linearization='akirich',
explicit=False):
r"""Pre-stack linearized seismic modelling operator.
Create operator to be applied to elastic property profiles
for generation of band-limited seismic angle gathers from a
linearized version of the Zoeppritz equation.
Parameters
----------
wav : :obj:`np.ndarray`
Wavelet in time domain (must had odd number of
elements and centered to zero)
theta : :obj:`np.ndarray`
Incident angles in degrees
vsvp : :obj:`float` or :obj:`np.ndarray`
VS/VP ratio (constant or time/depth variant)
nt0 : :obj:`int`, optional
number of samples (if ``vsvp`` is a scalar)
spatdims : :obj:`int` or :obj:`tuple`, optional
Number of samples along spatial axis (or axes)
(``None`` if only one dimension is available)
linearization : :obj:`str`, optional
choice of linearization, ``akirich``: Aki-Richards, ``fatti``: Fatti
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)
Returns
-------
Preop : :obj:`LinearOperator`
pre-stack modelling operator.
Raises
------
NotImplementedError
If ``linearization`` is not an implemented linearization
Notes
-----
Pre-stack seismic modelling is the process of constructing seismic
pre-stack data from three (or two) profiles of elastic parameters in time
(or depth) domain arranged in an input vector :math:`\mathbf{m}` of size
:math:`nt0 \times N`. This can be easily achieved using the following
forward model:
.. math::
d(t, \theta) = w(t) * \sum_{i=1}^N G_i(t, \theta) m_i(t)
where :math:`w(t)` is the time domain seismic wavelet. In compact form:
.. math::
\mathbf{d}= \mathbf{G} \mathbf{m}
On the other hand, pre-stack inversion aims at recovering the different
profiles of elastic properties from the band-limited seismic
pre-stack data.
"""
# create vsvp profile
vsvp = vsvp if isinstance(vsvp, np.ndarray) else vsvp * np.ones(nt0)
nt0 = len(vsvp)
ntheta = len(theta)
# organize dimensions
if spatdims is None:
dims = (nt0, ntheta)
spatdims = None
elif isinstance(spatdims, int):
dims = (nt0, ntheta, spatdims)
spatdims = (spatdims, )
else:
dims = (nt0, ntheta) + spatdims
if explicit:
# Create derivative operator
D = np.diag(0.5 * np.ones(nt0 - 1), k=1) - \
np.diag(0.5 * np.ones(nt0 - 1), -1)
D[0] = D[-1] = 0
D = block_diag(*([D] * 3))
# Create AVO operator
if linearization == 'akirich':
G1, G2, G3 = akirichards(theta, vsvp, n=nt0)
elif linearization == 'fatti':
G1, G2, G3 = fatti(theta, vsvp, n=nt0)
else:
logging.error('%s not an available linearization...',
linearization)
raise NotImplementedError('%s not an available linearization...' %
linearization)
G = [
np.hstack((np.diag(G1[itheta] * np.ones(nt0)),
np.diag(G2[itheta] * np.ones(nt0)),
np.diag(G3[itheta] * np.ones(nt0))))
for itheta in range(ntheta)
]
G = np.vstack(G).reshape(ntheta * nt0, 3 * nt0)
# Create wavelet operator
C = convmtx(wav, nt0)[:, len(wav) // 2:-len(wav) // 2 + 1]
C = [C] * ntheta
C = block_diag(*C)
# Combine operators
M = np.dot(C, np.dot(G, D))
return MatrixMult(M, dims=spatdims)
else:
# Create wavelet operator
Cop = Convolve1D(np.prod(np.array(dims)),
h=wav,
offset=len(wav) // 2,
dir=0,
dims=dims)
# create AVO operator
AVOop = AVOLinearModelling(theta,
vsvp,
spatdims=spatdims,
linearization=linearization)
# Create derivative operator
dimsm = list(dims)
dimsm[1] = AVOop.npars
Dop = FirstDerivative(np.prod(np.array(dimsm)),
dims=dimsm,
dir=0,
sampling=1.)
return Cop * AVOop * Dop
def PrestackWaveletModelling(m,
theta,
nwav,
wavc=None,
vsvp=0.5,
linearization='akirich'):
r"""Pre-stack linearized seismic modelling operator for wavelet.
Create operator to be applied to a wavelet for generation of
band-limited seismic angle gathers using a linearized version
of the Zoeppritz equation.
Parameters
----------
m : :obj:`np.ndarray`
elastic parameter profles of size :math:`[n_{t0} \times N]`
where :math:`N=3/2`
theta : :obj:`int`
Incident angles in degrees
nwav : :obj:`np.ndarray`
Number of samples of wavelet to be applied/estimated
wavc : :obj:`int`, optional
Index of the center of the wavelet
vsvp : :obj:`np.ndarray` or :obj:`float`, optional
VS/VP ratio
linearization : :obj:`str`, optional
choice of linearization, ``akirich``: Aki-Richards,
``fatti``: Fatti
Returns
-------
Mconv : :obj:`LinearOperator`
pre-stack modelling operator for wavelet estimation.
Raises
------
NotImplementedError
If ``linearization`` is not an implemented linearization
Notes
-----
Pre-stack seismic modelling for wavelet estimate is the process
of constructing seismic reflectivities using three (or two)
profiles of elastic parameters in time (or depth)
domain arranged in an input vector :math:`\mathbf{m}`
of size :math:`nt0 \times N`:
.. math::
d(t, \theta) = \sum_{i=1}^N G_i(t, \theta) m_i(t) * w(t)
where :math:`w(t)` is the time domain seismic wavelet. In compact form:
.. math::
\mathbf{d}= \mathbf{G} \mathbf{w}
On the other hand, pre-stack wavelet estimation aims at
recovering the wavelet given knowledge of the band-limited
seismic pre-stack data and the elastic parameter profiles.
"""
# Create vsvp profile
vsvp = vsvp if isinstance(vsvp, np.ndarray) else vsvp * np.ones(m.shape[0])
wavc = nwav // 2 if wavc is None else wavc
nt0 = len(vsvp)
ntheta = len(theta)
# Create derivative operator
D = np.diag(0.5 * np.ones(nt0 - 1), k=1) - \
np.diag(0.5 * np.ones(nt0 - 1), -1)
D[0] = D[-1] = 0
D = block_diag(*([D] * 3))
# Create AVO operator
if linearization == 'akirich':
G1, G2, G3 = akirichards(theta, vsvp, n=nt0)
elif linearization == 'fatti':
G1, G2, G3 = fatti(theta, vsvp, n=nt0)
else:
logging.error('%s not an available linearization...', linearization)
raise NotImplementedError('%s not an available linearization...' %
linearization)
G = [
np.hstack((np.diag(G1[itheta] * np.ones(nt0)),
np.diag(G2[itheta] * np.ones(nt0)),
np.diag(G3[itheta] * np.ones(nt0))))
for itheta in range(ntheta)
]
G = np.vstack(G).reshape(ntheta * nt0, 3 * nt0)
# Create infinite-reflectivity data
M = np.dot(G, np.dot(D, m.T.flatten())).reshape(ntheta, nt0)
Mconv = VStack([
MatrixMult(convmtx(M[itheta], nwav)[wavc:-nwav + wavc + 1])
for itheta in range(ntheta)
])
return Mconv
