def _run_sub_tests(self, st1, st2, lags_true): for window in ('valid', 'full'): for method in ('speed', 'memory'): with self.subTest(window=window, method=method): binsize = 1 * pq.s st1_binned = conv.BinnedSpikeTrain(st1, binsize=binsize) st2_binned = conv.BinnedSpikeTrain(st2, binsize=binsize) left, right = lags_true[window][(0, -1), ] cch_window, lags_window = sc.cross_correlation_histogram( st1_binned, st2_binned, window=(left, right), method=method, ) cch, lags = sc.cross_correlation_histogram(st1_binned, st2_binned, window=window) # target cross correlation cch_target = np.correlate(st1_binned.to_array()[0], st2_binned.to_array()[0], mode=window) self.assertEqual(len(lags_window), cch_window.shape[0]) assert_array_almost_equal(cch.magnitude, cch_window.magnitude) # the output is reversed since we cross-correlate # st2 with st1 rather than st1 with st2 (numpy behavior) assert_array_almost_equal(np.ravel(cch.magnitude), cch_target[::-1]) assert_array_equal(lags, lags_true[window]) assert_array_equal(lags, lags_window)
def test_border_correction(self): '''Test if the border correction for bins at the edges is correctly performed''' cch_corrected, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=True, binary=False, kernel=None) cch_corrected_mem, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=True, binary=False, kernel=None, method='memory') cch, _ = sc.cross_correlation_histogram(self.binned_st1, self.binned_st2, window='full', border_correction=False, binary=False, kernel=None) cch_mem, _ = sc.cross_correlation_histogram(self.binned_st1, self.binned_st2, window='full', border_correction=False, binary=False, kernel=None, method='memory') self.assertEqual(np.any(np.not_equal(cch, cch_corrected)), True) self.assertEqual(np.any(np.not_equal(cch_mem, cch_corrected_mem)), True)
def test_kernel(self): '''Test if the smoothing kernel is correctly defined, and wheter it is applied properly.''' smoothed_cch, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, kernel=np.ones(3)) smoothed_cch_mem, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, kernel=np.ones(3), method='memory') cch, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, kernel=None) cch_mem, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, kernel=None, method='memory') self.assertNotEqual(smoothed_cch.all, cch.all) self.assertNotEqual(smoothed_cch_mem.all, cch_mem.all) self.assertRaises( ValueError, sc.cch, self.binned_st1, self.binned_st2, kernel=np.ones(100)) self.assertRaises( ValueError, sc.cch, self.binned_st1, self.binned_st2, kernel=np.ones(100), method='memory') self.assertRaises( ValueError, sc.cch, self.binned_st1, self.binned_st2, kernel='BOX') self.assertRaises( ValueError, sc.cch, self.binned_st1, self.binned_st2, kernel='BOX', method='memory')
def test_border_correction(self): '''Test if the border correction for bins at the edges is correctly performed''' # check that nothing changes for valid lags cch_valid, _ = sc.cross_correlation_histogram(self.binned_st1, self.binned_st2, window='full', border_correction=True, binary=False, kernel=None) valid_lags = sc._CrossCorrHist.get_valid_lags(self.binned_st1, self.binned_st2) left_edge, right_edge = valid_lags[(0, -1), ] cch_builder = sc._CrossCorrHist(self.binned_st1, self.binned_st2, window=(left_edge, right_edge)) cch_valid = cch_builder.correlate_speed(cch_mode='valid') cch_corrected = cch_builder.border_correction(cch_valid) np.testing.assert_array_equal(cch_valid, cch_corrected) # test the border correction for lags without full overlap cch_full, lags_full = sc.cross_correlation_histogram(self.binned_st1, self.binned_st2, window='full') cch_full_corrected, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=True) num_bins_outside_window = np.min(np.abs( np.subtract.outer(lags_full, valid_lags)), axis=1) min_num_bins = min(self.binned_st1.num_bins, self.binned_st2.num_bins) border_correction = (cch_full_corrected / cch_full).magnitude.flatten() # exclude NaNs caused by zeros in the cch mask = np.logical_not(np.isnan(border_correction)) np.testing.assert_array_almost_equal( border_correction[mask], (float(min_num_bins) / (min_num_bins - num_bins_outside_window))[mask])
def test_annotations(self): cch, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, kernel=np.ones(3)) target_dict = dict(window='full', border_correction=False, binary=False, kernel=True, normalization='counts') self.assertIn('cch_parameters', cch.annotations) self.assertEqual(cch.annotations['cch_parameters'], target_dict)
def test_border_correction(self): '''Test if the border correction for bins at the edges is correctly performed''' cch_corrected, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=True, binary=False, kernel=None) cch_corrected_mem, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=True, binary=False, kernel=None, method='memory') cch, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=False, binary=False, kernel=None) cch_mem, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', border_correction=False, binary=False, kernel=None, method='memory') self.assertNotEqual(cch.all(), cch_corrected.all()) self.assertNotEqual(cch_mem.all(), cch_corrected_mem.all())
def test_window(self): """Test if the window parameter is correctly interpreted.""" cch_win, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30]) cch_win_mem, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30], method='memory') self.assertEqual(len(bin_ids), cch_win.shape[0]) assert_array_equal(bin_ids, np.arange(-30, 31, 1)) assert_array_equal( (bin_ids - 0.5) * self.binned_st1.bin_size, cch_win.times) assert_array_equal(bin_ids_mem, np.arange(-30, 31, 1)) assert_array_equal( (bin_ids_mem - 0.5) * self.binned_st1.bin_size, cch_win.times) assert_array_equal(cch_win, cch_win_mem) cch_unclipped, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) assert_array_equal(cch_win, cch_unclipped[19:80]) _, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[20, 30]) _, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[20, 30], method='memory') assert_array_equal(bin_ids, np.arange(20, 31, 1)) assert_array_equal(bin_ids_mem, np.arange(20, 31, 1)) _, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, -20]) _, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-30, -20], method='memory') assert_array_equal(bin_ids, np.arange(-30, -19, 1)) assert_array_equal(bin_ids_mem, np.arange(-30, -19, 1)) # Check for wrong assignments to the window parameter # Test for window longer than the total length of the spike trains self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60, 50]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50, 60]) # Test for no integer or wrong string in input self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25.5, 25.5]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='test')
def CorrelationPlot(ST, nr, bins, vis): b = 25001 # amount of bins the spikes get divided into sIO = ST delays = np.zeros((nr, nr)) show = vis for ll in range(0, nr): for m in range(0, nr): t_end = int(max(sIO[0])) t_s = int(min(sIO[0])) ioN = sIO[m] * pq.s ioM = sIO[ll] * pq.s st = n.SpikeTrain(ioN, t_start=t_s * pq.s, t_stop=(t_end + 1) * pq.s) st2 = n.SpikeTrain(ioM, t_start=t_s * pq.s, t_stop=(t_end + 1) * pq.s) x = conv.BinnedSpikeTrain(st, num_bins=bins, t_start=t_s * pq.s) x2 = conv.BinnedSpikeTrain(st2, num_bins=bins, t_start=t_s * pq.s) cor12 = stcorr.cross_correlation_histogram(x, x2, window='full') window = cor12[1] edges = [min(window), max(window)] st_obj = CrossCorrHist(x, x2, window=edges) k = st_obj.correlate_memory() # why does 'binnedspiketrain' does not have attribute 'get_num_spikes' # the code suggests that it does. delay = np.where(k == max(k)) if ll == m: norm_val = max(k) #print(delay[0][0]) #print() delays[ll, m] = delay[0][0] - max(window) #print(delay) #print(len(k)) t = np.linspace(-(t_end - t_s), (t_end - t_s), num=bins * 2 - 1) if show == 'yes': plt.figure() plt.title('IO cell 0 correlated with IO cell' + str(m)) plt.plot(t, k / norm_val) plt.ylabel('correlation value[-]') plt.xlabel('bins centered around zero') plt.show() return delays
def calcCCH(i, j, dataset): #use elephant to recreate cross_correlation_histograms cch = cross_correlation_histogram( (BinnedSpikeTrain(neoDataset[i], binsize=1 * ms)), (BinnedSpikeTrain(neoDataset[j], binsize=1 * ms)), window=[-10, 10], border_correction=True, binary=False, kernel=None) cchArray1 = np.array(cch[0][:, 0].magnitude) return cchArray1.max()
def test_window(self): '''Test if the window parameter is correctly interpreted.''' cch_win, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30]) cch_win_mem, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30]) assert_array_equal(bin_ids, np.arange(-30, 31, 1)) assert_array_equal( (bin_ids - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(bin_ids_mem, np.arange(-30, 31, 1)) assert_array_equal( (bin_ids_mem - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(cch_win, cch_win_mem) cch_unclipped, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) assert_array_equal(cch_win, cch_unclipped[19:80]) _, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[20, 30]) _, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[20, 30], method='memory') assert_array_equal(bin_ids, np.arange(20, 31, 1)) assert_array_equal(bin_ids_mem, np.arange(20, 31, 1)) _, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, -20]) _, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-30, -20], method='memory') assert_array_equal(bin_ids, np.arange(-30, -19, 1)) assert_array_equal(bin_ids_mem, np.arange(-30, -19, 1)) # Check for wrong assignments to the window parameter # Test for window longer than the total length of the spike trains self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60, 50]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50, 60]) # Test for no integer or wrong string in input self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25.5, 25.5]) self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='test')
def test_cross_correlation_histogram(self): ''' Test generic result of a cross-correlation histogram between two binned spike trains. ''' # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'full' (whole spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False, method='memory') # Check consistency two methods assert_array_equal(np.squeeze(cch_clipped.magnitude), np.squeeze(cch_clipped_mem.magnitude)) assert_array_equal(np.squeeze(cch_clipped.times), np.squeeze(cch_clipped_mem.times)) assert_array_equal(np.squeeze(cch_unclipped.magnitude), np.squeeze(cch_unclipped_mem.magnitude)) assert_array_equal(np.squeeze(cch_unclipped.times), np.squeeze(cch_unclipped_mem.times)) assert_array_almost_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_almost_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal(target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal(target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignalArray assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'valid' (only completely overlapping intervals of the # spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False, method='memory') # Check consistency two methods assert_array_equal(np.squeeze(cch_clipped.magnitude), np.squeeze(cch_clipped_mem.magnitude)) assert_array_equal(np.squeeze(cch_clipped.times), np.squeeze(cch_clipped_mem.times)) assert_array_equal(np.squeeze(cch_unclipped.magnitude), np.squeeze(cch_unclipped_mem.magnitude)) assert_array_equal(np.squeeze(cch_unclipped.times), np.squeeze(cch_unclipped_mem.times)) assert_array_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal(target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal(target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignalArray assert_array_equal((bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_equal((bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Check for wrong window parameter setting self.assertRaises(KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij') self.assertRaises(KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij', method='memory')
def test_window(self): '''Test if the window parameter is correctly interpreted.''' cch_win, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30]) cch_win_mem, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30]) assert_array_equal(bin_ids, np.arange(-30, 31, 1)) assert_array_equal( (bin_ids - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(bin_ids_mem, np.arange(-30, 31, 1)) assert_array_equal( (bin_ids_mem - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(cch_win, cch_win_mem) cch_unclipped, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) assert_array_equal(cch_win, cch_unclipped[19:80]) cch_win, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-25*pq.ms, 25*pq.ms]) cch_win_mem, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-25*pq.ms, 25*pq.ms], method='memory') assert_array_equal(bin_ids, np.arange(-25, 26, 1)) assert_array_equal( (bin_ids - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(bin_ids_mem, np.arange(-25, 26, 1)) assert_array_equal( (bin_ids_mem - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(cch_win, cch_win_mem) _, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[20, 30]) _, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[20, 30], method='memory') assert_array_equal(bin_ids, np.arange(20, 31, 1)) assert_array_equal(bin_ids_mem, np.arange(20, 31, 1)) _, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, -20]) _, bin_ids_mem = sc.cch( self.binned_st1, self.binned_st2, window=[-30, -20], method='memory') assert_array_equal(bin_ids, np.arange(-30, -19, 1)) assert_array_equal(bin_ids_mem, np.arange(-30, -19, 1)) # Cehck for wrong assignments to the window parameter self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60, 50]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60, 50], method='memory') self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50, 60]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50, 60], method='memory') self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25.5*pq.ms, 25*pq.ms]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25.5*pq.ms, 25*pq.ms], method='memory') self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25*pq.ms, 25.5*pq.ms]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25*pq.ms, 25.5*pq.ms], method='memory') self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60*pq.ms, 50*pq.ms]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60*pq.ms, 50*pq.ms], method='memory') self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50*pq.ms, 60*pq.ms]) self.assertRaises( ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50*pq.ms, 60*pq.ms], method='memory')
def test_cross_correlation_histogram(self): ''' Test generic result of a cross-correlation histogram between two binned spike trains. ''' # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'full' (whole spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False, method='memory') # Check consistency two methods assert_array_equal( np.squeeze(cch_clipped.magnitude), np.squeeze( cch_clipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_clipped.times), np.squeeze( cch_clipped_mem.times)) assert_array_equal( np.squeeze(cch_unclipped.magnitude), np.squeeze( cch_unclipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_unclipped.times), np.squeeze( cch_unclipped_mem.times)) assert_array_almost_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_almost_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal( target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal( target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignalArray assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'valid' (only completely overlapping intervals of the # spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False, method='memory') # Check consistency two methods assert_array_equal( np.squeeze(cch_clipped.magnitude), np.squeeze( cch_clipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_clipped.times), np.squeeze( cch_clipped_mem.times)) assert_array_equal( np.squeeze(cch_unclipped.magnitude), np.squeeze( cch_unclipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_unclipped.times), np.squeeze( cch_unclipped_mem.times)) assert_array_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal( target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal( target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignalArray assert_array_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Check for wrong window parameter setting self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij') self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij', method='memory')
def cch(block, unit1=0, unit2=1): # Load the data sts1 = [segment.spiketrains[unit1] for segment in block.segments] sts2 = [segment.spiketrains[unit2] for segment in block.segments] # Compute the CCH w = 2 * pq.ms # binsize for CCH maxlag = 200 * pq.ms # maximum correlation lag Nlags = int((maxlag / w).simplified) CCH = neo.AnalogSignal(np.zeros(2 * Nlags + 1) * pq.dimensionless, sampling_period=w, t_start=-maxlag) for st1, st2 in zip(sts1, sts2): CCH += corr.cross_correlation_histogram(conv.BinnedSpikeTrain(st1, w), conv.BinnedSpikeTrain(st2, w), window=[-Nlags, Nlags], border_correction=False, binary=True)[0] CCH = CCH / float(len(sts1)) # Compute PSTH psth1 = stats.time_histogram(sts1, binsize=w, output='rate').rescale('Hz') psth2 = stats.time_histogram(sts2, binsize=w, output='rate').rescale('Hz') # Compute ISI dist ISIpdf1 = misc.isi_pdf(sts1, bins=w, rng=[0 * pq.s, None], density=True) ISIpdf2 = misc.isi_pdf(sts2, bins=w, rng=[0 * pq.s, None], density=True) # plot plt.figure(figsize=(12, 8)) plt.subplots_adjust(top=.85, right=.85, left=.2, bottom=.1, hspace=.7, wspace=.3) num_row, num_col = 4, 3 ax = plt.subplot2grid((num_row, num_col), (0, 0), rowspan=1, colspan=2) misc.raster(sts1, ms=2, xlabel='time', ylabel='trial id', color='r') plt.subplot2grid((num_row, num_col), (1, 0), rowspan=1, colspan=2, sharex=ax) misc.raster(sts2, ms=2, xlabel='time', ylabel='trial id', color='b') plt.subplot2grid((num_row, num_col), (2, 0), rowspan=2, colspan=2, sharex=ax) plt.title('PSTH') plt.plot(psth1.times, psth1, color='r') plt.plot(psth2.times, psth2, color='b') ax.set_xlim(0, 4010) #max(psth1.times.magnitude)) plt.subplot2grid((num_row, num_col), (0, 2), rowspan=1, colspan=1) plt.plot([len(st) for st in sts1], range(1, len(sts1) + 1), '.-', ms=5, color='r') plt.title('Spike Count') plt.ylabel('trial id') plt.subplot2grid((num_row, num_col), (1, 2), rowspan=1, colspan=1) plt.plot([len(st) for st in sts2], range(1, len(sts2) + 1), '.-', ms=5, color='b') plt.ylabel('trial id') plt.subplot2grid((num_row, num_col), (2, 2), rowspan=2, colspan=1) plt.plot(ISIpdf1.times, ISIpdf1, color='r') plt.plot(ISIpdf2.times, ISIpdf2, color='b') plt.title('ISI distribution') # Plot the CCH plt.figure(figsize=(12, 8)) plt.subplot2grid((2, 2), (1, 1), rowspan=2, colspan=2) plt.plot(CCH.times.rescale(pq.ms), CCH, 'k-', label='raw CCH') plt.title('CCH') plt.xlabel('time lag (%s)' % (CCH.times.units.__str__().split(' ')[-1])) plt.ylabel('counts') plt.xlim(-maxlag, maxlag) plt.legend() plt.show()
def test_cross_correlation_histogram(self): ''' Test generic result of a cross-correlation histogram between two binned spike trains. ''' # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'full' (whole spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = \ sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False, method='memory') # Check consistency two methods assert_array_equal( np.squeeze(cch_clipped.magnitude), np.squeeze( cch_clipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_clipped.times), np.squeeze( cch_clipped_mem.times)) assert_array_equal( np.squeeze(cch_unclipped.magnitude), np.squeeze( cch_unclipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_unclipped.times), np.squeeze( cch_unclipped_mem.times)) assert_array_almost_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_almost_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal( target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check cross correlation function for several displacements tau # Note: Use Elephant corrcoeff to verify result tau = [-25.0, 0.0, 13.0] # in ms for t in tau: # adjust t_start, t_stop to shift by tau t0 = np.min([self.st_1.t_start + t * pq.ms, self.st_2.t_start]) t1 = np.max([self.st_1.t_stop + t * pq.ms, self.st_2.t_stop]) st1 = neo.SpikeTrain(self.st_1.magnitude + t, units='ms', t_start=t0 * pq.ms, t_stop=t1 * pq.ms) st2 = neo.SpikeTrain(self.st_2.magnitude, units='ms', t_start=t0 * pq.ms, t_stop=t1 * pq.ms) binned_sts = conv.BinnedSpikeTrain([st1, st2], binsize=1 * pq.ms, t_start=t0 * pq.ms, t_stop=t1 * pq.ms) # caluclate corrcoef corrcoef = sc.corrcoef(binned_sts)[1, 0] # expand t_stop to have two spike trains with same length as st1, # st2 st1 = neo.SpikeTrain(self.st_1.magnitude, units='ms', t_start=self.st_1.t_start, t_stop=self.st_1.t_stop + np.abs(t) * pq.ms) st2 = neo.SpikeTrain(self.st_2.magnitude, units='ms', t_start=self.st_2.t_start, t_stop=self.st_2.t_stop + np.abs(t) * pq.ms) binned_st1 = conv.BinnedSpikeTrain( st1, t_start=0 * pq.ms, t_stop=(50 + np.abs(t)) * pq.ms, binsize=1 * pq.ms) binned_st2 = conv.BinnedSpikeTrain( st2, t_start=0 * pq.ms, t_stop=(50 + np.abs(t)) * pq.ms, binsize=1 * pq.ms) # calculate CCHcoef and take value at t=tau CCHcoef, _ = sc.cch(binned_st1, binned_st2, cross_corr_coef=True) left_edge = - binned_st1.num_bins + 1 tau_bin = int(t / float(binned_st1.binsize.magnitude)) assert_array_equal( corrcoef, CCHcoef[tau_bin - left_edge].magnitude) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal( target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignal assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'valid' (only completely overlapping intervals of the # spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = \ sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False, method='memory') # Check consistency two methods assert_array_equal( np.squeeze(cch_clipped.magnitude), np.squeeze( cch_clipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_clipped.times), np.squeeze( cch_clipped_mem.times)) assert_array_equal( np.squeeze(cch_unclipped.magnitude), np.squeeze( cch_unclipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_unclipped.times), np.squeeze( cch_unclipped_mem.times)) assert_array_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal( target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal( target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignal assert_array_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Check for wrong window parameter setting self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij') self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij', method='memory')
connectionDictionary = connectionDict for i in range(len(neoDataset)): for j in range(len(neoDataset)): #if i != j: connectionDictionary[i][j] = connectionDictionary[i][j] + calcCCH( i, j, neoDataset) return connectionDictionary #This code will produce a single cross correlogram binned_st1 = BinnedSpikeTrain(neoDataset[0], binsize=1 * ms) binned_st2 = BinnedSpikeTrain(neoDataset[5], binsize=1 * ms) cch = cross_correlation_histogram(binned_st1, binned_st2, window=[-10, 10], border_correction=True, binary=True, kernel=None) print(cch) cchArray = cch[0][:, 0].magnitude.round() cchArrayTime = cch[0].times.magnitude cchArrayNP = np.array(cchArray) print("argmax is:", cchArrayNP.max()) print(corrcoef(x, binary=True)) #calculate the cross-correlograms of the entire dataset, #produce the corresponding correlation matrix ''' print(calcCCH(8,9,neoDataset)) correlationArray = generateCorrelationMatrix(neoDataset)
def test_window(self): '''Test if the window parameter is correctly interpreted.''' cch_win, bin_ids = sc.cch(self.binned_st1, self.binned_st2, window=[-30, 30]) cch_win_mem, bin_ids_mem = sc.cch(self.binned_st1, self.binned_st2, window=[-30, 30]) assert_array_equal(bin_ids, np.arange(-30, 31, 1)) assert_array_equal((bin_ids - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(bin_ids_mem, np.arange(-30, 31, 1)) assert_array_equal((bin_ids_mem - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(cch_win, cch_win_mem) cch_unclipped, _ = sc.cross_correlation_histogram(self.binned_st1, self.binned_st2, window='full', binary=False) assert_array_equal(cch_win, cch_unclipped[19:80]) cch_win, bin_ids = sc.cch(self.binned_st1, self.binned_st2, window=[-25 * pq.ms, 25 * pq.ms]) cch_win_mem, bin_ids_mem = sc.cch(self.binned_st1, self.binned_st2, window=[-25 * pq.ms, 25 * pq.ms], method='memory') assert_array_equal(bin_ids, np.arange(-25, 26, 1)) assert_array_equal((bin_ids - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(bin_ids_mem, np.arange(-25, 26, 1)) assert_array_equal((bin_ids_mem - 0.5) * self.binned_st1.binsize, cch_win.times) assert_array_equal(cch_win, cch_win_mem) _, bin_ids = sc.cch(self.binned_st1, self.binned_st2, window=[20, 30]) _, bin_ids_mem = sc.cch(self.binned_st1, self.binned_st2, window=[20, 30], method='memory') assert_array_equal(bin_ids, np.arange(20, 31, 1)) assert_array_equal(bin_ids_mem, np.arange(20, 31, 1)) _, bin_ids = sc.cch(self.binned_st1, self.binned_st2, window=[-30, -20]) _, bin_ids_mem = sc.cch(self.binned_st1, self.binned_st2, window=[-30, -20], method='memory') assert_array_equal(bin_ids, np.arange(-30, -19, 1)) assert_array_equal(bin_ids_mem, np.arange(-30, -19, 1)) # Cehck for wrong assignments to the window parameter self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60, 50]) self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60, 50], method='memory') self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50, 60]) self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50, 60], method='memory') self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25.5 * pq.ms, 25 * pq.ms]) self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25.5 * pq.ms, 25 * pq.ms], method='memory') self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25 * pq.ms, 25.5 * pq.ms]) self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-25 * pq.ms, 25.5 * pq.ms], method='memory') self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60 * pq.ms, 50 * pq.ms]) self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-60 * pq.ms, 50 * pq.ms], method='memory') self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50 * pq.ms, 60 * pq.ms]) self.assertRaises(ValueError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window=[-50 * pq.ms, 60 * pq.ms], method='memory')
def test_cross_correlation_histogram(self): ''' Test generic result of a cross-correlation histogram between two binned spike trains. ''' # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'full' (whole spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='full', binary=False, method='memory') # Check consistency two methods assert_array_equal( np.squeeze(cch_clipped.magnitude), np.squeeze( cch_clipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_clipped.times), np.squeeze( cch_clipped_mem.times)) assert_array_equal( np.squeeze(cch_unclipped.magnitude), np.squeeze( cch_unclipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_unclipped.times), np.squeeze( cch_unclipped_mem.times)) assert_array_almost_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_almost_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal( target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check cross correlation function for several displacements tau # Note: Use Elephant corrcoeff to verify result tau = [-25.0, 0.0, 13.0] # in ms for t in tau: # adjust t_start, t_stop to shift by tau t0 = np.min([self.st_1.t_start+t*pq.ms, self.st_2.t_start]) t1 = np.max([self.st_1.t_stop+t*pq.ms, self.st_2.t_stop]) st1 = neo.SpikeTrain(self.st_1.magnitude+t, units='ms', t_start = t0*pq.ms, t_stop = t1*pq.ms) st2 = neo.SpikeTrain(self.st_2.magnitude, units='ms', t_start = t0*pq.ms, t_stop = t1*pq.ms) binned_sts = conv.BinnedSpikeTrain([st1, st2], binsize=1*pq.ms, t_start = t0*pq.ms, t_stop = t1*pq.ms) # caluclate corrcoef corrcoef = sc.corrcoef(binned_sts)[1,0] # expand t_stop to have two spike trains with same length as st1, st2 st1 = neo.SpikeTrain(self.st_1.magnitude, units='ms', t_start = self.st_1.t_start, t_stop = self.st_1.t_stop+np.abs(t)*pq.ms) st2 = neo.SpikeTrain(self.st_2.magnitude, units='ms', t_start = self.st_2.t_start, t_stop = self.st_2.t_stop+np.abs(t)*pq.ms) binned_st1 = conv.BinnedSpikeTrain( st1, t_start=0*pq.ms, t_stop=(50+np.abs(t))*pq.ms, binsize=1 * pq.ms) binned_st2 = conv.BinnedSpikeTrain( st2, t_start=0 * pq.ms, t_stop=(50+np.abs(t))*pq.ms, binsize=1 * pq.ms) # calculate CCHcoef and take value at t=tau CCHcoef, _ = sc.cch(binned_st1, binned_st2, cross_corr_coef=True) l = - binned_st1.num_bins + 1 tau_bin = int(t/float(binned_st1.binsize.magnitude)) assert_array_equal(corrcoef, CCHcoef[tau_bin-l].magnitude) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='full') assert_array_equal( target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignal assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_almost_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'valid' (only completely overlapping intervals of the # spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True) cch_unclipped, bin_ids_unclipped = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False) cch_clipped_mem, bin_ids_clipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=True, method='memory') cch_unclipped_mem, bin_ids_unclipped_mem = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, window='valid', binary=False, method='memory') # Check consistency two methods assert_array_equal( np.squeeze(cch_clipped.magnitude), np.squeeze( cch_clipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_clipped.times), np.squeeze( cch_clipped_mem.times)) assert_array_equal( np.squeeze(cch_unclipped.magnitude), np.squeeze( cch_unclipped_mem.magnitude)) assert_array_equal( np.squeeze(cch_unclipped.times), np.squeeze( cch_unclipped_mem.times)) assert_array_equal(bin_ids_clipped, bin_ids_clipped_mem) assert_array_equal(bin_ids_unclipped, bin_ids_unclipped_mem) # Check normal correlation Note: Use numpy correlate to verify result. # Note: numpy conventions for input array 1 and input array 2 are # swapped compared to Elephant! mat1 = self.binned_st1.to_array()[0] mat2 = self.binned_st2.to_array()[0] target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal( target_numpy, np.squeeze(cch_unclipped.magnitude)) # Check correlation using binary spike trains mat1 = np.array(self.binned_st1.to_bool_array()[0], dtype=int) mat2 = np.array(self.binned_st2.to_bool_array()[0], dtype=int) target_numpy = np.correlate(mat2, mat1, mode='valid') assert_array_equal( target_numpy, np.squeeze(cch_clipped.magnitude)) # Check the time axis and bin IDs of the resulting AnalogSignal assert_array_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_unclipped.times) assert_array_equal( (bin_ids_clipped - 0.5) * self.binned_st1.binsize, cch_clipped.times) # Check for wrong window parameter setting self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij') self.assertRaises( KeyError, sc.cross_correlation_histogram, self.binned_st1, self.binned_st2, window='dsaij', method='memory')