示例#1
0
def test_precalc_psd():
    nfft = 256
    E,V = libtfr.dpss(200, 3, 5)
    D = libtfr.mfft_precalc(nfft, E, V)
    assert_array_equal(E, D.tapers)
    Z = D.mtpsd(sig)
    assert_tuple_equal(Z.shape, (nfft//2 + 1,))
    assert_equal(Z.dtype, libtfr.DTYPE)
示例#2
0
def test_precalc_psd():
    nfft = 256
    E, V = libtfr.dpss(200, 3, 5)
    D = libtfr.mfft_precalc(nfft, E, V)
    assert_array_equal(E, D.tapers)
    Z = D.mtpsd(sig)
    assert_tuple_equal(Z.shape, (nfft // 2 + 1, ))
    assert_equal(Z.dtype, libtfr.DTYPE)
示例#3
0
def goodness(signal, freq_range=None, D=None):
    """Compute the goodness of pitch of a signal."""
    if D is None:
        D = libtfr.dpss(len(signal), 1.5, 1)[0]
    signal = signal * D[0, :]
    if freq_range is None:
        freq_range = FREQ_RANGE
    if np.all(signal == 0):
        return 0
    else:
        return np.max(cepstrum(signal)[25:freq_range])
示例#4
0
def mtfft(tl, **kwargs):
    """
    Multitaper fourier transform from point process times

    [J,Nsp,f] = mtfftpt(tl, **kwargs)

    Input:
          tl          ragged array of event times
    Optional keyword arguments:
          NW          time-bandwidth parameter for DPSS tapers (default 3)
          k           number of DPSS tapers to use (default nw*2-1)
          time_range  the range of times to analyze (default is to use range of tl)
          Fs          the frequency resolution (default 1)
          fpass       frequency band to be used in the calculation in the form
                      (fmin, fmax). Default (0, Fs/2)
          nfft        number of frequency bins for transform

    Output:
          J       complex spectrum with dimensions (freq x chan x tapers)
          Nsp     total spike count in each trial, with dimension (chan,)
          f       frequency grid, with dimension (freq,)

    Note on units: if the units of the data are T, the corresponding frequency units
                   are in 1/T (sec -> Hz; msec -> kHz)
    """
    from libtfr import fgrid, dpss
    from numpy import arange, sqrt
    import toelis

    NW = kwargs.get('NW', 3)
    K = kwargs.get('k', NW*2-1)
    Fs = kwargs.get('Fs', 1)
    fpass = kwargs.get('fpass', (0, Fs/2.))

    dt = 1./Fs
    try:
        mintime, maxtime = kwargs['time_range']
        t = arange(mintime, maxtime, dt)
    except KeyError:
        mintime, maxtime = toelis.range(tl)
        # pad around spike times to avoid edge effects
        t = arange(mintime-dt, maxtime+2*dt, dt)

    N = len(t)
    nfft = kwargs.get('nfft', N)
    f,findx = fgrid(Fs, nfft, fpass)
    tapers = dpss(N, NW, K)[0].T * sqrt(Fs)

    J, Nsp = _mtfft(tl, tapers, nfft, t, f, findx)
    return J, Nsp, f
示例#5
0
def mtfft(tl, **kwargs):
    """
    Multitaper fourier transform from point process times

    [J,Nsp,f] = mtfftpt(tl, **kwargs)

    Input:
          tl          ragged array of event times
    Optional keyword arguments:
          NW          time-bandwidth parameter for DPSS tapers (default 3)
          k           number of DPSS tapers to use (default nw*2-1)
          time_range  the range of times to analyze (default is to use range of tl)
          Fs          the frequency resolution (default 1)
          fpass       frequency band to be used in the calculation in the form
                      (fmin, fmax). Default (0, Fs/2)
          nfft        number of frequency bins for transform

    Output:
          J       complex spectrum with dimensions (freq x chan x tapers)
          Nsp     total spike count in each trial, with dimension (chan,)
          f       frequency grid, with dimension (freq,)

    Note on units: if the units of the data are T, the corresponding frequency units
                   are in 1/T (sec -> Hz; msec -> kHz)
    """
    from libtfr import fgrid, dpss
    from numpy import arange, sqrt
    import toelis

    NW = kwargs.get('NW', 3)
    K = kwargs.get('k', NW * 2 - 1)
    Fs = kwargs.get('Fs', 1)
    fpass = kwargs.get('fpass', (0, Fs / 2.))

    dt = 1. / Fs
    try:
        mintime, maxtime = kwargs['time_range']
        t = arange(mintime, maxtime, dt)
    except KeyError:
        mintime, maxtime = toelis.range(tl)
        # pad around spike times to avoid edge effects
        t = arange(mintime - dt, maxtime + 2 * dt, dt)

    N = len(t)
    nfft = kwargs.get('nfft', N)
    f, findx = fgrid(Fs, nfft, fpass)
    tapers = dpss(N, NW, K)[0].T * sqrt(Fs)

    J, Nsp = _mtfft(tl, tapers, nfft, t, f, findx)
    return J, Nsp, f
示例#6
0
def test_dpss_bad_args():
    E,V = libtfr.dpss(128, -5, 3)
示例#7
0
def run_dpss(args, concentrations, means):
    from numpy import ones_like
    E,V = libtfr.dpss(*args)
    assert_array_almost_equal(V, concentrations)
    assert_array_almost_equal(E.mean(1), means)
    assert_array_almost_equal((E**2).sum(1), ones_like(V))
示例#8
0
def test_dpss_bad_args():
    E, V = libtfr.dpss(128, -5, 3)
示例#9
0
def run_dpss(args, concentrations, means):
    from numpy import ones_like
    E, V = libtfr.dpss(*args)
    assert_array_almost_equal(V, concentrations)
    assert_array_almost_equal(E.mean(1), means)
    assert_array_almost_equal((E**2).sum(1), ones_like(V))
示例#10
0
# -*- coding: utf-8 -*-
# -*- mode: python -*-

#import pstats, cProfile

from numpy.random import randn
import libtfr

sig = randn(17590)
D = libtfr.dpss(256, 3, 5)

#cProfile.runctx("D.mtspec(sig, 10)", globals(), locals(), "Profile.prof")
#s = pstats.Stats("Profile.prof")
#s.strip_dirs().sort_stats("time").print_stats()
示例#11
0
def mtstft(tl, window, step, **kwargs):
    """
    Multitaper short time fourier transform from point process times

    [J,Nsp,f,t] = mtstft(tl, window, step**kwargs)

    Input:
          tl          ragged array of event times
          window      duration of short time analysis window
          step        step size between windows
    Optional keyword arguments:
          NW          time-bandwidth parameter for DPSS tapers (default 3)
          k           number of DPSS tapers to use (default nw*2-1)
          time_range  the range of times to analyze (default is to use range of tl)
          Fs          the frequency resolution (default 1)
          fpass       frequency band to be used in the calculation in the form
                      (fmin, fmax). Default (0, Fs/2)
          nfft        number of frequency bins for transform

    Output:
          J       complex spectrum with dimensions (freq x time x tapers x chan)
          Nsp     total spike count in each trial, with dimension (time, chan)
          f       frequency grid, with dimension (freq,)
          t       time grid, with dimension (time,)

    Note on units: if the units of the data are T, the corresponding frequency units
                   are in 1/T (sec -> Hz; msec -> kHz)
    """
    from libtfr import fgrid, dpss
    from numpy import arange, sqrt, zeros
    import toelis

    NW = kwargs.get('NW', 3)
    K = kwargs.get('k', NW*2-1)
    Fs = kwargs.get('Fs', 1)
    dt = 1./ Fs
    fpass = kwargs.get('fpass', (0, Fs/2.))

    C = len(tl)
    twin = arange(0, window, dt)
    N = len(twin)
    nfft = kwargs.get('nfft', N)
    f,findx = fgrid(Fs, nfft, fpass)
    tapers = dpss(N, NW, K)[0].T * sqrt(Fs)

    try:
        mintime, maxtime = kwargs['time_range']
    except KeyError:
        mintime, maxtime = toelis.range(tl)
        # pad around spikes
        mintime -= dt
        maxtime += 2*dt
    tgrid = arange(mintime, maxtime, step)

    J = zeros((f.size, tgrid.size, K, C), dtype='D')
    Nsp = zeros((tgrid.size, C), dtype='i')
    for i, offset in enumerate(tgrid):
        j,n = _mtfft(tl, tapers, nfft, twin + offset, f, findx)
        J[:,i,:,:] = j
        Nsp[i,:] = n

    return J, Nsp, f, tgrid
示例#12
0
def mtstft(tl, window, step, **kwargs):
    """
    Multitaper short time fourier transform from point process times

    [J,Nsp,f,t] = mtstft(tl, window, step**kwargs)

    Input:
          tl          ragged array of event times
          window      duration of short time analysis window
          step        step size between windows
    Optional keyword arguments:
          NW          time-bandwidth parameter for DPSS tapers (default 3)
          k           number of DPSS tapers to use (default nw*2-1)
          time_range  the range of times to analyze (default is to use range of tl)
          Fs          the frequency resolution (default 1)
          fpass       frequency band to be used in the calculation in the form
                      (fmin, fmax). Default (0, Fs/2)
          nfft        number of frequency bins for transform

    Output:
          J       complex spectrum with dimensions (freq x time x tapers x chan)
          Nsp     total spike count in each trial, with dimension (time, chan)
          f       frequency grid, with dimension (freq,)
          t       time grid, with dimension (time,)

    Note on units: if the units of the data are T, the corresponding frequency units
                   are in 1/T (sec -> Hz; msec -> kHz)
    """
    from libtfr import fgrid, dpss
    from numpy import arange, sqrt, zeros
    import toelis

    NW = kwargs.get('NW', 3)
    K = int(kwargs.get('k', NW * 2 - 1))
    Fs = kwargs.get('Fs', 1)
    dt = 1. / Fs
    fpass = kwargs.get('fpass', (0, Fs / 2.))

    C = len(tl)
    twin = arange(0, window, dt)
    N = len(twin)
    nfft = kwargs.get('nfft', N)
    f, findx = fgrid(Fs, nfft, fpass)
    tapers = dpss(N, NW, K)[0].T * sqrt(Fs)

    try:
        mintime, maxtime = kwargs['time_range']
    except KeyError:
        mintime, maxtime = toelis.range(tl)
        # pad around spikes
        mintime -= dt
        maxtime += 2 * dt
    tgrid = arange(mintime, maxtime, step)

    J = zeros((f.size, tgrid.size, K, C), dtype='D')
    Nsp = zeros((tgrid.size, C), dtype='i')
    for i, offset in enumerate(tgrid):
        j, n = _mtfft(tl, tapers, nfft, twin + offset, f, findx)
        J[:, i, :, :] = j
        Nsp[i, :] = n

    return J, Nsp, f, tgrid