def test_pcorrelate_normalization(data):
    """Test pcorrelate algorithm using np.histogram."""
    t, u, unit = data
    bins = pyc.make_loglags(-6, 0, 20, base=10, return_int=False) / unit
    Gn = pyc.pcorrelate(t, u, bins, normalize=True)
    G = pyc.pcorrelate(t, u, bins, normalize=False)
    Gn2 = pyc.pnormalize(G, t, u, bins)
    assert (Gn == Gn2).all()
Beispiel #2
0
def calc_fcs_dd_da(burstsph, bins, seed=1):
    ts_d = burstsph.loc[burstsph.stream == 'DexDem', 'timestamp'].values.copy()
    ts_a = burstsph.loc[burstsph.stream == 'DexAem', 'timestamp'].values.copy()
    np.random.seed(seed)
    ts_d += np.random.randint(-25, 25, size=ts_d.size)
    ts_a += np.random.randint(-25, 25, size=ts_a.size)
    CC_DA = pyc.pcorrelate(ts_d, ts_a, bins, normalize=True) + 1
    AC_DD = pyc.pcorrelate(ts_d, ts_d, bins, normalize=True) + 1
    return CC_DA, AC_DD
Beispiel #3
0
def xcorrFine(x, y, bins):

    print('starting xcorr')
    print('len(x), len(y)', len(x), len(y))
    print('len(bins)', len(bins))
    cc = pyc.pcorrelate(x, y, bins)

    zero_idx = np.floor(len(cc) / 2)
    shift = np.argmax(cc) - zero_idx
    print('shift', shift)

    return cc, shift
Beispiel #4
0
    def antibunching(self, samples, timegate):

        rep = self.meta['tags']['TTResult_SyncRate']['value']
        maxCorr = round(1 / rep * 1e6, 1) + (round((1 / rep * 1e6) / 2, 1))
        l = -maxCorr * 1e-6
        m = maxCorr * 1e-6
        sp = samples
        p = (m - l) / sp
        lags = np.arange(l, m, p)
        self.antibunchX = (lags[:len(lags) - 1]) * 1e6

        correctNanotimes = self.nanotimes * self.meta['nanotimes_unit']
        a = self.truetime[(self.detectors == 0)
                          & (correctNanotimes > (timegate / 1e9))]
        b = self.truetime[(self.detectors == 1)
                          & (correctNanotimes > (timegate / 1e9))]

        self.G = pyc.pcorrelate(a, b, lags, 1)
        self.H = pyc.pcorrelate(b, a, lags, 1)
        self.antibunchY = (self.G + self.H) / 2

        return self.antibunchY, self.antibunchX
def test_pcorrelate_vs_ucorrelate(data):
    t, u, unit = data
    binwidth = 50e-6
    bins_tt = np.arange(0, t.max() * unit, binwidth) / unit
    bins_uu = np.arange(0, u.max() * unit, binwidth) / unit
    tx, _ = np.histogram(t, bins=bins_tt)
    ux, _ = np.histogram(u, bins=bins_uu)
    Gu = pyc.ucorrelate(tx, ux)
    maxlag_sec = 1.2  # seconds
    lagbins = (np.arange(0, maxlag_sec, binwidth) / unit).astype('int64')
    Gp = pyc.pcorrelate(t, u, lagbins) * int(binwidth / unit)
    n = 6000
    err = np.abs(Gp[:n] - Gu[:n]) / (0.5 * (Gp[:n] + Gu[:n]))
    assert err.max() < 0.23
    assert err.mean() < 0.05
def corr4(i1, i2, window, bin_length=0.001):
    """
    Correlation between spike trains. Accepts spike rasters.

    Parameters
    --------
    i1, i2:
        Indices of spike rasters to compare
    window:
        The maximum time lag to consider, in seconds.
    bin_length:
        Length of each bin. Default is 1 ms.
    """
    i1 = clusters[i1][:2]
    i2 = clusters[i2][:2]
    x1 = asc.read_raster(exp, stim, *i1)
    x2 = asc.read_raster(exp, stim, *i2)
    corr_bins = np.arange(-window, window, bin_length)
    corr = pycorrelate.pcorrelate(x1, x2, corr_bins, normalize=True)
    return corr
def test_pcorrelate(data):
    """Test pcorrelate algorithm using np.histogram."""
    t, u, unit = data
    n = 10000  # ~ 3s of data
    t, u = t[:n], u[:n]
    bins = pyc.make_loglags(1, 8, 20, base=10, return_int=True)
    nbins = len(bins) - 1
    G = pyc.pcorrelate(t, u, bins)

    Y = np.zeros(nbins, dtype=np.int64)
    for ti in t:
        Yc, _ = np.histogram(u - ti, bins=bins)
        Y += Yc
    Gn = Y / np.diff(bins)

    # The last bin in np.histogram includes the right edge while pcorrelate
    # does not. This creates a potential discrepancy for the last bin.
    assert np.allclose(G, Gn)
    assert np.allclose(G[:-1], Gn[:-1])
    # However the value in the last bin when using np.histogram needs to be
    # >= than pcorrelate value.
    assert (Gn[-1] >= G[-1]).all()
Beispiel #8
0
x = correlator.get_x_axis_normalized()
y = correlator.get_corr_normalized()

p.semilogx(x, y)
p.show()


# Use this to compare noise of the correlation curve (sth. seems to be off in the pycorrelate
# implementation...

import pycorrelate

t1 = mt[ch1_indeces]
t2 = mt[ch2_indeces]
bins = pycorrelate.make_loglags(0, np.log10(tau[-2]), 30)
G = pycorrelate.pcorrelate(t1.astype(np.float), t2.astype(np.float), bins, True)
p.semilogx(bins[1:], G)
p.show()

%time G=pycorrelate.pcorrelate(t1.astype(np.float), t2.astype(np.float), bins, True)


#######################################
# Selection based on time windows
#######################################
import tttrlib
import numpy as np
import pylab as p

photons = tttrlib.TTTR('../../examples/bh/BH_SPC132.spc', 2)
mt = photons.macro_times
import numpy as np
import time
from scipy.fftpack import fft, ifft, fftshift
import matplotlib.pyplot as plt
from numpy.lib.stride_tricks import as_strided
import random
from scipy.linalg import toeplitz
import pycorrelate as pyc

arr1 = np.array(range(1, 1001))
arr2a = np.array([])
arr2b = np.array(range(500, 1001))
arr2 = np.concatenate((arr2a, arr2b))
lowerIdx = -1000
upperIdx = 0
numBins = 500
binSize = (upperIdx - lowerIdx) / numBins
bins = np.linspace(lowerIdx, upperIdx, numBins)
cc = pyc.pcorrelate(arr2, arr1, bins)

plt.figure()
plt.plot(bins[1:len(bins)], cc)
plt.show()

shift = (np.argmax(cc) - int(numBins / 2)) * binSize
print('shift', shift)
def corr2(x1, x2=None, window=0.05, res=0.001):
    if x2 is None:
        x2 = x1
    corr = pycorrelate.pcorrelate(x1, x2, window, res)
    return corr
#%%
from scipy import signal


def plotpeaks(i, j):
    xcorr = xcorrs[i, j, :]
    peaks = signal.find_peaks(xcorr, prominence=200)[0]
    plt.plot(xcorr)
    plt.plot(peaks, xcorr[peaks], 'x')
    plt.axvline(xcorr.shape[0] / 2, color='grey', linestyle='dashed')
    plt.show()


plotpeaks(10, 1)
#%%
spikes = asc.read_raster(exp, stim, 1, 1)
spikes2 = asc.read_raster(exp, stim, 1, 3)

t = np.arange(0, spikes[-1], 0.001)
bsp = asc.binspikes(spikes, t)
bsp2 = asc.binspikes(spikes2, t)

#plt.plot(corr(bsp, window=40))

sprcorwindow = 0.05
corr_bin = np.arange(-sprcorwindow, sprcorwindow, .001)

pycorp = pycorrelate.pcorrelate(spikes, spikes2, corr_bin, normalize=True)
plt.plot(pycorp)
plt.show()