I have been using the Ricker wavelet function and noticed that you get a different sample representation of the wavelet depending on whether you end up with an odd or even number of samples in the output.

That seems like strange behaviour, I would expect a consistent sample representation and just to get an additional zero sample in the sequence. It does affect the wavelet produced, as far as amplitude is concerned, you get a slightly higher amplitude wavelet than you bargained for.

See:
https://github.com/stevejpurves/geoscribbles/blob/master/notebooks/Ricker_with_odd_or_even_samples.ipynb

Looking at the code I think there is a 1/2 sample correction in there that isn't actually being helpful.

for critical angles to be valid (and for the arcsin to compute), the velocity comparison should be vp1<vp2 and vp1<vs2

https://github.com/agile-geoscience/bruges/blob/6b7d48438328ea3c73a62e0d422ae3f46e7ab054/bruges/reflection/reflection.py#L34

https://github.com/agile-geoscience/bruges/blob/6b7d48438328ea3c73a62e0d422ae3f46e7ab054/bruges/reflection/reflection.py#L37

There are 2 functions in Fatiando for plotting wiggles and a seismic section. I kinda want to get rid of them because I don't use them and they endup unmaintained. Do you want them in bruges? I'd be happy to submit a PR.

Here is an example: http://www.fatiando.org/dev/gallery/seismic/convolutional_model.html

cc @eusoubrasileiro (the author of that code)

This module should be refactored.

It does not tolerate NaNs in the t-d function, eg if you pass a Vp curve with Nans in it.

I'd like to be able to look up times and depths singly.

Sorting out the confusing 'layout' of wavelets, kernels, and filter functions. Wavelets, which are really just 1D kernels, should also be available as 2D kernels.

Elastic impedance & Normalized Elastic Impedance
see subsurfwiki for equations http://subsurfwiki.org/wiki/Elastic_impedance

Not sure yet how many equations this affects, but we should vectorize all of them.

For example, you should be able to pass Vp, Vs, RHOB logs of length m to the reflectivity equations, plus a 1D array of incidence angles of length n, and get back an m × n array of impedances.

Alessandro's (@aadm) has made a good start on converting Per Avseth's QSI epic into numpy and Matplotlib friendly functions. Could make a good little cookbook / recipe collection for bruges.

http://aadm.github.io/2016-02-12-rock-physics-templates.html

A function that computes integrated trace of post-stack seismic amplitude data. Vectorized of course.

Optionally perhaps.

Function should look something like this,

    """converts bulk density into 'density porosity' based 
        on a given matrix density (Rho_matrix)
        Rho_matrix (sandstone) : 2.65 g/cc
        Rho_matrix (Limestome): 2.71 g/cc
        Rho_matrix (Dolomite): 2.876 g/cc
        Rho_matrix (Anyhydrite): 2.977 g/cc
        Rho_matrix (Salt): 2.032 g/cc

        Rho_fluid (fresh water): 1.0 g/cc (is this more mud-like?)
        Rho_fluid (salt water): 1.1 g/cc
        see wiki.aapg.org/Density-neutron_log_porosity
        returns density porosity log """
        
       # put some code here to check that everything is in SI units or at 
       # least check that Rho_matrix, RHOB, AND Rho_fluid, have the same units

        return ( Rho_matrix - RHOB ) / (Rho_matrix - Rho_fluid )

http://wiki.aapg.org/Density-neutron_log_porosity

I think it's more convenient to get the wavelets back in the first dimension, so that w[0] is the first wavelet in the bank.

Guys you should check the way you pass parameters to bruges.anisotropy.blangy, because right now the first set of parameters (vp0, vs0 and rho0) are assigned to the lower medium and the second set to the upper medium -- and this is the opposite to all the other equations like bruges.reflection.akirichards etc. where you assign the first set of parameters to the upper medium.

The EI equation has some issues:

• It doesn't work on multi-dimensional input.
• Normalization doesn't work as expected.

Also, it could be improved, for example:

• Let user change K.
• Let user choose to use sin or tan for the alpha term.

To match our other libraries.

Seems much simpler to use.

Fix the failing tests and cover the rest of the rockphysics module

Right now only does 3. Should be easy.

Should maybe just be able to pass in a list of logs.

Calling it a bug.

Passing :) but empty :(

http://bruges.readthedocs.org/en/latest/index.html

There's an @ operator in the CoordTransform class.

http://wiki.seg.org/wiki/Dictionary:Dix_formula

We should change the zoeppritz matrix type to complex and check that we get complex reflection coeffs. beyond the critical angle.

Not sure where to put it... maybe it's just a general utility.

See

Comparison of shear impedances inverted from stacked PS and SS data: Example from Rulison Field, Colorado, ELDAR GULIYEV, Occidental Petroleum Corporation and REINALDO J. MICHELENA, iReservoir.com, p 1388, The Leading Edge, November 2009.

http://www.ireservoir.com/downloads/TLE_PS_Inversion_Nov2009.pdf

After Matt's blog post I wanted to use Blangy's equation to do some anisotropic AVO modeling. I think it would be pretty easy to add it to agilegeo.avo:

def blangy(vp1,vs1,rho1,d1,e1,vp2,vs2,rho2,d2,e2,theta):
    inc_angle = np.radians(theta)
    trans_angle = np.arcsin(np.sin(inc_angle) * vp2/vp1)
    theta = 0.5 * (inc_angle + trans_angle)
    vp  = (vp1 + vp2)/2.0
    vs  = (vs1 + vs2)/2.0
    rho  = (rho1 + rho2)/2.0
    dvp = vp2-vp1
    dvs = vs2-vs1
    drho = rho2-rho1
    dd = d2-d1
    de = e2-e1
    A = 0.5 * (drho/rho + dvp/vp)
    B = 2.0 * (vs**2 / vp**2) * ((drho/rho + 2 * dvs/vs)) * np.sin(theta)**2
    C = 0.5 * (dvp/vp) * np.tan(theta)**2
    D = 0.5 * dd * np.sin(theta)**2
    E = 0.5 * (dd - de) * np.sin(theta)**2 * np.tan(theta)**2
    isotropic = A - B + C
    anisotropic = A - B + C + D - E
    return isotropic, anisotropic, (A, -B, C, D, -E)

Should be able to get a wavelet bank by passing an array of 4-tuples (or similar 2D array) to ormsby. This works for ricker() and sweep().

We can add to this as we go:

New

• Leo's NMO eqn
• tau-p
• Evan's wavelet estimation tutorial
• some simple curve estimation/fill-in (without scikit)
• coloured inversion
• Dix and inverse Dix
• Random stuff from Ross Crain's collection

Need improvement

• better / easier specdecomp, with some new algos (at least S-transform)
• better time-depth conversion

The f1 parameter passed to scipy.signal.chirp() is wrong. Also needs vectorizing properly.

Make a wrapper for convolve so you can make a 3D synthetic from a filter bank on a 2D RC series.

http://earthscience.stackexchange.com/q/7463/70

Need a ray tracing function for 1.5D, 2D and 3D velocity models for offset synthetics.

For interval velocities from RMS velocities.

Matteo got warnings when running Backus, coming from the padded slicing.

Currently uses:

• scipy.fftpack.fft — bruges/attribute/spectrogram.py
• scipy.signal.fftconvolve — bruges/attribute/energy.py, bruges/util/util.py
• scipy.signal.get_window — bruges/attribute/spectrogram.py
• scipy.signal.hilbert — bruges/filters/wavelets.py
• scipy.signal.chirp — bruges/filters/wavelets.py
• scipy.interpolate.interp1d — bruges/transform/timedepthconv.py

Add a function to the reflection module to make it easier to construct a reflectivity series for a set of logs.

Needs #38 to be sensible.

Just noticed that the module docs pages are empty: https://bruges.readthedocs.io/en/latest/bruges.noise.html

Probably a bug in sphinx. I'll take a look when I get home tonight.

T**alpha-type gain, perhaps in util?

Something to do with __init__.py files maybe?

Looking at the tutorial @kwinkunks recently posted, I noticed that the convolution itself for forward modeling is not implemented in bruges. It's a non-trivial piece of code to apply to multiple traces it would be good to have it in there so we don't have to write np.apply_along_axis all the time :)

For example:

• Download a couple of open seismic datasets.
• Maybe a couple of wells, ideally on the seismic, ideally with elastic properties.

Maybe a good idea:

• Use TQDM
• Allow downloading subsets?
• Prolly best to use npy formats directly? SEG-Y might be bad idea, esp since no reader in bruges.

And tests with doctest.

There is a matrix inversion inside a loop which is likely going to slow things down. We can rewrite the code as the inverse of one large matrix and avoid the loops. Should be able to extend to an arbitrary number of angles and samples using np.kron.

A big job but might help with, e.g. jit.

Add this method to the rockphysics.backus stuff...

https://doi.org/10.1190/1.2723204