morlet wavelet

0.1. definition

It's a complex sine wave windowed by a Gaussian \[ \psi_{f}(t) = e^{2\pi ift}e^{\frac{-t^2}{2\sigma^2}} \]

where \(\sigma = \frac{n}{2\pi f}\).

Explanation of components:

The first term is a complex sine wave
The second term is the Gaussian envelope

Important things:

\(f\) is the frequency-of-interest. This is the frequency that will be "matched"
\(\sigma\) controls the temporal resolution. We can increase the number of cycles, \(n\), to get better frequency resolution, but lose temporal resolution

Now, I think that \(\sigma\) does not need \(\frac{1}{f}\), but it is rather by convention to set the scale that way. We could make \(\sigma\) any old number, as long as we multiply by the correct normalizing term. I think

1. properties

The morlet wavelet is not admissable. We can add a correction term but this is not done in practice

2. relevant links

def morlet(sfreq, freqs, n_cycles=7.0, sigma=None, zero_mean=False):
    """Compute Morlet wavelets for the given frequency range.
    Parameters
    ----------
    sfreq : float
        The sampling Frequency.
    freqs : array
        Frequency range of interest (1 x Frequencies).
    n_cycles : float | array of float, default 7.0
        Number of cycles. Fixed number or one per frequency.
    sigma : float, default None
        It controls the width of the wavelet ie its temporal
        resolution. If sigma is None the temporal resolution
        is adapted with the frequency like for all wavelet transform.
        The higher the frequency the shorter is the wavelet.
        If sigma is fixed the temporal resolution is fixed
        like for the short time Fourier transform and the number
        of oscillations increases with the frequency.
    zero_mean : bool, default False
        Make sure the wavelet has a mean of zero.
    Returns
    -------
    Ws : list of array
        The wavelets time series.
    """
    Ws = list()
    n_cycles = np.atleast_1d(n_cycles)

    freqs = np.array(freqs)
    if np.any(freqs <= 0):
        raise ValueError("all frequencies in 'freqs' must be "
                         "greater than 0.")

    if (n_cycles.size != 1) and (n_cycles.size != len(freqs)):
        raise ValueError("n_cycles should be fixed or defined for "
                         "each frequency.")
    for k, f in enumerate(freqs):
        if len(n_cycles) != 1:
            this_n_cycles = n_cycles[k]
        else:
            this_n_cycles = n_cycles[0]
        # fixed or scale-dependent window
        if sigma is None:
            sigma_t = this_n_cycles / (2.0 * np.pi * f)
        else:
            sigma_t = this_n_cycles / (2.0 * np.pi * sigma)
        # this scaling factor is proportional to (Tallon-Baudry 98):
        # (sigma_t*sqrt(pi))^(-1/2);
        t = np.arange(0., 5. * sigma_t, 1.0 / sfreq)
        t = np.r_[-t[::-1], t[1:]]
        oscillation = np.exp(2.0 * 1j * np.pi * f * t)
        gaussian_enveloppe = np.exp(-t ** 2 / (2.0 * sigma_t ** 2))
        if zero_mean:  # to make it zero mean
            real_offset = np.exp(- 2 * (np.pi * f * sigma_t) ** 2)
            oscillation -= real_offset
        W = oscillation * gaussian_enveloppe
        W /= np.sqrt(0.5) * np.linalg.norm(W.ravel())
        Ws.append(W)
    return Ws

note that in the above implementation from the MNE library, \(\sigma\) can be set independently of \(f\). For almost all continuous wavelet transforms, the \(\sigma\) is proportional to \(\frac{1}{f}\), so that low frequencies have poor temporal resolution.
note that for scipy cwt and scipy morelet, they build the foi into the width. That is, you don't have a choice to separately specify them. It is assumed that \(width = \frac{w\cdot fs}{foi\cdot 2f\pi}\) where \(fs\) is the sampling rate
In the superlets paper, they do the same thing. If you want to use a different sigma, you need to change the implementation
in brainstorm you can set the temporal resolution per frequency
math introduction
stack overflow question I haven't read