def setUp(self): # These two arrays must be such that they do not have coincidences # spanning across two neighbor bins assuming ms bins [0,1),[1,2),... self.test_array_1d_0 = [ 1.3, 7.56, 15.87, 28.23, 30.9, 34.2, 38.2, 43.2 ] self.test_array_1d_1 = [1.02, 2.71, 18.82, 28.46, 28.79, 43.6] # Build spike trains self.st_0 = neo.SpikeTrain(self.test_array_1d_0, units='ms', t_stop=50.) self.st_1 = neo.SpikeTrain(self.test_array_1d_1, units='ms', t_stop=50.) # And binned counterparts self.binned_st = conv.BinnedSpikeTrain([self.st_0, self.st_1], t_start=0 * pq.ms, t_stop=50. * pq.ms, binsize=1 * pq.ms)
def _new_spiketrain_v1(cls, signal, t_stop, units=None, dtype=None, copy=True, sampling_rate=1.0 * pq.Hz, t_start=0.0 * pq.s, waveforms=None, left_sweep=None, name=None, file_origin=None, description=None, array_annotations=None, annotations=None, segment=None, unit=None): ''' A function to map :meth:`BaseAnalogSignal.__new__` to function that does not do the unit checking. This is needed for :module:`pickle` to work. ''' if annotations is None: annotations = {} if isinstance(array_annotations, dict): # these in fact are the annotations in the old API annotations = array_annotations obj = neo.SpikeTrain(signal, t_stop, units, dtype, copy, sampling_rate, t_start, waveforms, left_sweep, name, file_origin, description, **annotations) else: obj = neo.SpikeTrain(signal, t_stop, units, dtype, copy, sampling_rate, t_start, waveforms, left_sweep, name, file_origin, description, array_annotations, **annotations) obj.segment = segment obj.unit = unit return obj
def test_spade_raise_error(self): self.assertRaises(TypeError, spade.spade, [[1, 2, 3], [3, 4, 5]], 1 * pq.ms, 4) self.assertRaises(AttributeError, spade.spade, [ neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s) ], 1 * pq.ms, 4) self.assertRaises( AttributeError, spade.spade, [ neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s) ], 1 * pq.ms, 4, min_neu=-3) self.assertRaises( AttributeError, spade.pvalue_spectrum, [ neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s) ], 1 * pq.ms, 4, 3 * pq.ms, n_surr=-3) self.assertRaises(AttributeError, spade.test_signature_significance, ((2, 3, 0.2), (2, 4, 0.1)), 0.01, corr='try') self.assertRaises(AttributeError, spade.approximate_stability, (), np.array([]), n_subsets=-3)
def write_sorting(sorting, save_path, sampling_frequency, check_suffix=True): ''' Save sorting extractor to MEArec format. Parameters ---------- sorting: SortingExtractor Sorting extractor object to be saved save_path: str .h5 or .hdf5 path sampling_frequency: int Sampling frequency in Hz ''' assert HAVE_MREX, "To use the MEArec extractors, install MEArec: \n\n pip install MEArec\n\n" save_path = Path(save_path) if save_path.is_dir(): print( "The file will be saved as sorting.h5 in the provided folder") save_path = save_path / 'sorting.h5' if (save_path.suffix == '.h5' or save_path.suffix == '.hdf5') or (not check_suffix): # create neo spike trains spiketrains = [] for u in sorting.get_unit_ids(): st = neo.SpikeTrain(times=sorting.get_unit_spike_train(u) / float(sampling_frequency) * pq.s, t_start=np.min( sorting.get_unit_spike_train(u) / float(sampling_frequency)) * pq.s, t_stop=np.max( sorting.get_unit_spike_train(u) / float(sampling_frequency)) * pq.s) st.annotate(unit_id=u) spiketrains.append(st) duration = np.max([st.t_stop.magnitude for st in spiketrains]) info = { 'recordings': { 'fs': sampling_frequency }, 'spiketrains': { 'duration': duration } } rec_dict = {'spiketrains': spiketrains} recgen = mr.RecordingGenerator(rec_dict=rec_dict, info=info) mr.save_recording_generator(recgen, str(save_path), verbose=False) else: raise Exception("Provide a folder or an .h5/.hdf5 as 'save_path'")
def create_hierarchy(cls, many_to_many): b = neo.Block() for ns in range(cls.SEGMENTS): b.segments.append(neo.Segment()) channels = [] if many_to_many: channels = [ neo.RecordingChannel(name='Shared %d' % i, index=i + cls.CHANNELS) for i in range(cls.CHANNELS / 2) ] for ng in range(cls.CHANNEL_GROUPS): rcg = neo.RecordingChannelGroup() for nu in range(cls.UNITS): unit = neo.Unit() for ns in range(cls.SEGMENTS): spike = neo.Spike(0 * pq.s) unit.spikes.append(spike) b.segments[ns].spikes.append(spike) st = neo.SpikeTrain([] * pq.s, 0 * pq.s) unit.spiketrains.append(st) b.segments[ns].spiketrains.append(st) rcg.units.append(unit) if not many_to_many: for nc in range(cls.CHANNELS): rc = neo.RecordingChannel(name='Single %d' % nc, index=nc) rc.recordingchannelgroups.append(rcg) rcg.recordingchannels.append(rc) else: for nc in range(cls.CHANNELS): if nc % 2 == 0: rc = neo.RecordingChannel(name='Single %d' % (nc / 2), index=nc / 2) else: rc = channels[nc / 2] rc.recordingchannelgroups.append(rcg) rcg.recordingchannels.append(rc) rcg.channel_indexes = sp.array( [c.index for c in rcg.recordingchannels]) rcg.channel_names = sp.array( [c.name for c in rcg.recordingchannels]) b.recordingchannelgroups.append(rcg) neo.io.tools.create_many_to_one_relationship(b) return b
def test_bins_spike_train_using_its_properties(self): a = neo.SpikeTrain(sp.array([1000.0]) * pq.ms, t_start=500.0 * pq.ms, t_stop=1500.0 * pq.ms) sampling_rate = 4.0 * pq.Hz expected = {0: [sp.array([0, 0, 1, 0])]} expectedBins = sp.array([0.5, 0.75, 1.0, 1.25, 1.5]) * pq.s actual, actualBins = tools.bin_spike_trains({0: [a]}, sampling_rate) self.assertEqual(len(expected), len(actual)) self.assertEqual(len(expected[0]), len(actual[0])) assert_array_equal(expected[0][0], actual[0][0]) assert_array_almost_equal(expectedBins, actualBins.rescale(expectedBins.units))
def test_bin_shuffling_empty_train(self): self.bin_size = 3 * pq.ms self.max_displacement = 10 empty_spiketrain = neo.SpikeTrain([] * pq.ms, t_stop=500 * pq.ms) binned_spiketrain = conv.BinnedSpikeTrain(empty_spiketrain, self.bin_size) surrogate_train = surr.bin_shuffling( binned_spiketrain, max_displacement=self.max_displacement, n_surrogates=1)[0] self.assertEqual(np.sum(surrogate_train.to_bool_array()), 0)
def test_concatenate_spiketrains(): from exana.misc import concatenate_spiketrains spiketrain1 = neo.SpikeTrain(times=np.arange(10), t_stop=10, units='s', waveforms=np.ones((10,1,5)) * pq.V) spiketrain2 = neo.SpikeTrain(times=np.arange(10, 25), t_stop=25, units='s', waveforms=np.ones((15,1,5)) * pq.V) spiketrain = concatenate_spiketrains([spiketrain1, spiketrain2]) spiketrain_true = np.concatenate((np.arange(10), np.arange(10, 25))) waveforms_true = np.concatenate((np.ones((10,1,5)), np.ones((15,1,5)))) assert np.array_equal(spiketrain.times.magnitude, spiketrain_true) assert spiketrain.times.units == pq.s.units assert np.array_equal(spiketrain.waveforms.magnitude, waveforms_true) assert spiketrain.waveforms.units == pq.V assert spiketrain.t_stop == 25 * pq.s with pytest.raises(ValueError): spiketrain2 = neo.SpikeTrain(times=np.arange(10, 25), t_stop=25, units='ms', waveforms=np.ones((15,1,5)) * pq.V) spiketrain = concatenate_spiketrains([spiketrain1, spiketrain2])
def test_dither_spike_train_false_edges(self): spiketrain = neo.SpikeTrain( [90, 150, 180, 350] * pq.ms, t_stop=500 * pq.ms) n_surrogates = 2 shift = 10 * pq.ms surrogate_trains = surr.dither_spike_train( spiketrain, shift=shift, n_surrogates=n_surrogates, edges=False) for surrogate_train in surrogate_trains: for i in range(len(surrogate_train)): self.assertLessEqual(surrogate_train[i], spiketrain.t_stop)
def test_jitter_spikes_unequal_binsize(self): st = neo.SpikeTrain([90, 150, 180, 480] * pq.ms, t_stop=500 * pq.ms) binsize = 75 * pq.ms surrog = surr.jitter_spikes(st, binsize=binsize, n=1)[0] bin_ids_orig = np.array((st.view(pq.Quantity) / binsize).rescale( pq.dimensionless).magnitude, dtype=int) bin_ids_surr = np.array((surrog.view(pq.Quantity) / binsize).rescale( pq.dimensionless).magnitude, dtype=int) self.assertTrue(np.all(bin_ids_orig == bin_ids_surr))
def test_binned_spiketrain_neg_times_list(self): a = neo.SpikeTrain( [-6.5, 0.5, 0.7, 1.2, 3.1, 4.3, 5.5, 6.7] * pq.s, t_start=-7 * pq.s, t_stop=7 * pq.s) b = neo.SpikeTrain( [-0.1, -0.7, 1.2, 2.2, 4.3, 5.5, 8.0] * pq.s, t_start=-1 * pq.s, t_stop=8 * pq.s) spiketrains = [a, b] # not the same t_start and t_stop self.assertRaises(ValueError, cv.BinnedSpikeTrain, spiketrains=spiketrains, bin_size=self.bin_size) t_start, t_stop = get_common_start_stop_times(spiketrains) self.assertEqual(t_start, -1 * pq.s) self.assertEqual(t_stop, 7 * pq.s) x_bool = cv.BinnedSpikeTrain(spiketrains, bin_size=self.bin_size, t_start=t_start, t_stop=t_stop) y_bool = [[0, 1, 1, 0, 1, 1, 1, 1], [1, 0, 1, 1, 0, 1, 1, 0]] assert_array_equal(x_bool.to_bool_array(), y_bool)
def input_freq(port_name, freq, duration, weight, offset=None): freq = pq.Quantity(freq, 'kHz') duration = pq.Quantity(duration, 'ms') isi = 1 / freq if offset is None: offset = isi else: offset = pq.Quantity(offset, 'ms') train = neo.SpikeTrain(numpy.arange(offset, duration, isi), units='ms', t_stop=duration, t_start=offset) return (port_name, train, weight)
def test_extract(self): # test synchrofact search taking into account adjacent bins # this requires an additional loop with shifted binning sampling_rate = 1 / pq.s spiketrains = [ neo.SpikeTrain([1, 5, 9, 11, 13, 20] * pq.s, t_stop=21 * pq.s), neo.SpikeTrain([1, 4, 7, 12, 16, 18] * pq.s, t_stop=21 * pq.s) ] correct_annotations = np.array([[2, 2, 1, 3, 3, 1], [2, 2, 1, 3, 1, 1]]) self._test_template(spiketrains, correct_annotations, sampling_rate, spread=1, mode='extract', in_place=True, deletion_threshold=2)
def test_consistency_errors(self): a = self.spiketrain_a b = neo.SpikeTrain([-2, -1] * pq.s, t_start=-2 * pq.s, t_stop=-1 * pq.s) self.assertRaises(ValueError, cv.BinnedSpikeTrain, [a, b], t_start=5, t_stop=0, binsize=pq.s, num_bins=10) b = neo.SpikeTrain([-7, -8, -9] * pq.s, t_start=-9 * pq.s, t_stop=-7 * pq.s) self.assertRaises(ValueError, cv.BinnedSpikeTrain, b, t_start=0, t_stop=10, binsize=pq.s, num_bins=10) self.assertRaises(ValueError, cv.BinnedSpikeTrain, a, t_start=0 * pq.s, t_stop=10 * pq.s, binsize=3 * pq.s, num_bins=10) b = neo.SpikeTrain([-4, -2, 0, 1] * pq.s, t_start=-4 * pq.s, t_stop=1 * pq.s) self.assertRaises(TypeError, cv.BinnedSpikeTrain, b, binsize=-2 * pq.s, t_start=-4 * pq.s, t_stop=0 * pq.s)
def test_integration(self): """ The test is written according to the notebook (for developers only): https://github.com/INM-6/elephant-tutorials/blob/master/ simple_test_asset.ipynb """ # define parameters np.random.seed(1) size_group = 3 size_sse = 3 T = 60 * pq.ms delay = 9 * pq.ms bins_between_sses = 3 time_between_sses = 9 * pq.ms # ground truth for pmats starting_bin_1 = int((delay / self.bin_size).magnitude.item()) starting_bin_2 = int( (2 * delay / self.bin_size + time_between_sses / self.bin_size ).magnitude.item()) indices_pmat_1 = np.arange(starting_bin_1, starting_bin_1 + size_sse) indices_pmat_2 = np.arange(starting_bin_2, starting_bin_2 + size_sse) indices_pmat = (np.concatenate((indices_pmat_1, indices_pmat_2)), np.concatenate((indices_pmat_2, indices_pmat_1))) # generate spike trains spiketrains = [neo.SpikeTrain([index_spiketrain, index_spiketrain + size_sse + bins_between_sses] * self.bin_size + delay + 1 * pq.ms, t_stop=T) for index_group in range(size_group) for index_spiketrain in range(size_sse)] index_proba = { "high": (np.array([9, 9, 10, 10, 10, 11, 11]), np.array([3, 4, 3, 4, 5, 4, 5])), "medium": (np.array([8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12]), np.array([2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6])), "low": (np.array([7, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13]), np.array([2, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7, 6, 7])) } expected_sses = {1: {(9, 3): {0, 3, 6}, (10, 4): {1, 4, 7}, (11, 5): {2, 5, 8}}} self._test_integration_subtest(spiketrains, spiketrains_y=spiketrains, indices_pmat=indices_pmat, index_proba=index_proba, expected_sses=expected_sses)
def segment_from_recording_device(devices, variables_to_include, id_lists, t_stop, name="segment00"): """ Extract data from a NEST recording device and return it as a Neo Segment object. """ def get_data(device, variable, id_list): events = nest.GetStatus(device, 'events')[0] ids = events['senders'] values = events[variable] data = {} for id in id_list: data[id] = values[ids == id] assert len(data) > 0 return data segment = neo.Segment(name=name, rec_datetime=datetime.now()) for device, variable, id_list in zip(devices, variables_to_include, id_lists): print(name, device, variable) data = get_data(device, variable, id_list) if variable == 'times': print(" adding spiketrain") id0 = min(id_list) segment.spiketrains = [ neo.SpikeTrain(spiketrain, t_start=0.0, t_stop=t_stop, units='ms', source_id=id, source_index=id - id0) for id, spiketrain in data.items() ] else: print(" adding signal") source_ids = np.array(id_list) channel_indices = source_ids - source_ids.min() signal_array = np.vstack(data.values()).T segment.analogsignalarrays = [ neo.AnalogSignalArray(signal_array, units='mV', t_start=0.0 * ms, sampling_period=0.1 * ms, name=variable, channel_index=channel_indices, source_ids=source_ids) ] return segment
def build_block(data_file): """(plaintextfile_path) -> neo.core.block.Block Thie function reads a plain text file (data_file) with the data exported (per waveform) from Plexon Offline Sorter after sorting and returns a neo.Block with spiketrains ordered in any number of 10 minute segments. For practicality and Plexon management of channels names, units and channels have been ignored in the block structure.""" raw_data = pd.read_csv(data_file, sep=',', header=0, usecols=[0, 1, 2]) ord_times = raw_data.groupby(['Channel Name', 'Unit'])['Timestamp'] new_block = neo.Block() chx = neo.ChannelIndex(index=None, name='MEA_60') new_block.channel_indexes.append(chx) # Next line will not work properly if last spike happens # exactly at the end of the recording num_segments = range(int(raw_data['Timestamp'].max() // 600 + 1)) for ind in num_segments: seg = neo.Segment(name='segment {}'.format(ind), index=ind) new_block.segments.append(seg) for name, group in ord_times: time_stamps = ord_times.get_group(name).values inter = 600 # Number of seconds in 10 minutes first_seg = neo.SpikeTrain( time_stamps[time_stamps < inter], units='sec', t_start=0, t_stop=inter) new_block.segments[0].spiketrains.append(first_seg) new_unit = neo.Unit(name=name) sptrs = [first_seg] for seg in num_segments[1:-1]: seg_train = neo.SpikeTrain(time_stamps[(time_stamps > seg * inter) & (time_stamps < ((seg + 1) * inter))], units='sec', t_start=(seg * inter), t_stop=((seg + 1) * inter)) new_block.segments[seg].spiketrains.append(seg_train) sptrs.append(seg_train) last_seg = neo.SpikeTrain(time_stamps[time_stamps > (num_segments[-1] * inter)], units='sec', t_start=(num_segments[-1]) * inter, t_stop=((num_segments[-1] + 1) * inter)) new_block.segments[num_segments[-1]].spiketrains.append(last_seg) sptrs.append(last_seg) new_unit.spiketrains = sptrs chx.units.append(new_unit) return new_block
def test_dither_spike_train_false_edges(self): st = neo.SpikeTrain([90, 150, 180, 350] * pq.ms, t_stop=500 * pq.ms) nr_surr = 2 shift = 10 * pq.ms surrs = surr.dither_spike_train(st, shift=shift, n=nr_surr, edges=False) for surrog in surrs: for i in range(len(surrog)): self.assertLessEqual(surrog[i], st.t_stop)
def test_dither_spike_train_output_decimals(self): st = neo.SpikeTrain([90, 150, 180, 350] * pq.ms, t_stop=500 * pq.ms) n_surrogates = 2 shift = 10 * pq.ms surrogate_trains = surr.dither_spike_train( st, shift=shift, n_surrogates=n_surrogates, decimals=3) for surrogate_train in surrogate_trains: for i in range(len(surrogate_train)): self.assertNotEqual(surrogate_train[i] - int(surrogate_train[i]) * pq.ms, surrogate_train[i] - surrogate_train[i])
def test_timescale_errors(self): spikes = neo.SpikeTrain([1, 5, 7, 8] * pq.ms, t_stop=10 * pq.ms) binsize = 1 * pq.ms spikes_bin = conv.BinnedSpikeTrain(spikes, binsize) # Tau max with no units tau_max = 1 self.assertRaises(ValueError, sc.spike_train_timescale, spikes_bin, tau_max) # Tau max that is not a multiple of the binsize tau_max = 1.1 * pq.ms self.assertRaises(ValueError, sc.spike_train_timescale, spikes_bin, tau_max)
def test_dither_spikes_false_edges(self): st = neo.SpikeTrain([90, 150, 180, 350] * pq.ms, t_stop=500 * pq.ms) n_surrogates = 2 dither = 10 * pq.ms surrogate_trains = surr.dither_spikes(st, dither=dither, n_surrogates=n_surrogates, edges=False) for surrogate_train in surrogate_trains: for i in range(len(surrogate_train)): self.assertLessEqual(surrogate_train[i], st.t_stop)
def test_filter_process_with_spiketrain_h05(self): st = neo.SpikeTrain(self.test_array, units='s', t_stop=2.1) target = self.targ_h05 res = mft._filter_process(0.5 * pq.s, 0.5 * pq.s, st, 2.01 * pq.s, np.array([[0.5], [1.7], [0.4]])) assert_array_almost_equal(res[1], target[1], decimal=3) self.assertRaises(ValueError, mft._filter_process, 0.5, 0.5 * pq.s, st, 2.01 * pq.s, np.array([[0.5], [1.7], [0.4]])) self.assertRaises(ValueError, mft._filter_process, 0.5 * pq.s, 0.5, st, 2.01 * pq.s, np.array([[0.5], [1.7], [0.4]])) self.assertRaises(ValueError, mft._filter_process, 0.5 * pq.s, 0.5 * pq.s, self.test_array, 2.01 * pq.s, np.array([[0.5], [1.7], [0.4]]))
def test_trial_shuffling_empty_train_concatenated(self): empty_spiketrain = neo.SpikeTrain([] * pq.ms, t_stop=500 * pq.ms) trial_length = 200 * pq.ms trial_separation = 50 * pq.ms dither = 10 * pq.ms surrogate_train = surr._trial_shifting_of_concatenated_spiketrain( empty_spiketrain, dither=dither, n_surrogates=1, trial_length=trial_length, trial_separation=trial_separation)[0] self.assertEqual(len(surrogate_train), 0)
def test_spread_0(self): # basic test with a minimum number of two spikes per synchrofact # only taking into account multiple spikes # within one bin of size 1 / sampling_rate sampling_rate = 1 / pq.s spiketrains = [ neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, t_stop=20 * pq.s), neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, t_stop=20 * pq.s) ] correct_annotations = np.array([[2, 1, 1, 1, 2, 1], [2, 1, 1, 1, 2, 1]]) self._test_template(spiketrains, correct_annotations, sampling_rate, spread=0, mode='delete', in_place=True, deletion_threshold=2)
def test_randomise_spikes_output_decimals(self): spiketrain = neo.SpikeTrain([90, 150, 180, 350] * pq.ms, t_stop=500 * pq.ms) n_surrogates = 2 surrogate_trains = surr.randomise_spikes(spiketrain, n_surrogates=n_surrogates, decimals=3) for surrogate_train in surrogate_trains: for i in range(len(surrogate_train)): self.assertNotEqual( surrogate_train[i] - int(surrogate_train[i]) * pq.ms, surrogate_train[i] - surrogate_train[i])
def test_spiketrains_findable(self): # same test as `test_spread_0` with the addition of # a neo structure: we must not overwrite the spiketrain # list of the segment before determining the index sampling_rate = 1 / pq.s segment = neo.Segment() segment.spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, t_stop=20*pq.s), neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, t_stop=20*pq.s)] segment.create_relationship() correct_annotations = np.array([[2, 1, 1, 1, 2, 1], [2, 1, 1, 1, 2, 1]]) self._test_template(segment.spiketrains, correct_annotations, sampling_rate, spread=0, mode='delete', in_place=True, deletion_threshold=2)
def test_binarize_with_spiketrain_round(self): st = neo.SpikeTrain(self.test_array_1d, units='ms', t_stop=10.0, sampling_rate=10.0) times = np.arange(0, 10. + .1, .1) target = np.zeros_like(times).astype('bool') for time in np.round(self.test_array_1d, 1): target[get_nearest(times, time)] = True times = pq.Quantity(times, units='ms') res, tres = cv.binarize(st, return_times=True) assert_array_almost_equal(res, target, decimal=9) assert_array_almost_equal(tres, times, decimal=9)
def multiTag2SpikeTrain(tag, tStart, tStop): ''' Create a neo.spiketrain from nix.multitag :param tag: nix.multitag :param tStart: float, time of start of the spike train in units of the multitag :param tStop: float, time of stop of the spike train in units of the multitag :return: neo.spiketrain ''' sp = neo.SpikeTrain(times=[], t_start=tStart, t_stop=tStop, units=qu.s) if len(tag.positions): spikeTimes = np.array(tag.positions) * qu.Quantity(1, tag.units[0]) spikeTimesFiltered = spikeTimes[np.logical_and(spikeTimes > tStart, spikeTimes < tStop)] if spikeTimesFiltered.shape[0]: sp = neo.SpikeTrain(times=spikeTimesFiltered.magnitude, t_start=tStart, t_stop=tStop, units=tag.units[0]) return sp
def test_trains(self): trains = {} trains[0] = neo.SpikeTrain( sp.zeros(2) * pq.ms, 0 * pq.ms, waveforms=[[[-1, -2], [1, 2]], [[-1, -2], [1, 2]]] * pq.mV) trains[1] = trains[0] means = {} means[1] = neo.Spike(0 * pq.ms, waveform=[[-1, -1], [1, 1]] * pq.mV) exp = qa.variance_explained(trains, means) self.assertAlmostEqual(exp[0][0], 1) self.assertAlmostEqual(exp[0][0], 1) self.assertAlmostEqual(exp[1][0], 1) self.assertAlmostEqual(exp[1][1], 0.75)
def concatenate_spike_trains(trains): """ Concatenates spike trains. :param sequence trains: :class:`neo.core.SpikeTrain` objects to concatenate. :returns: A spike train consisting of the concatenated spike trains. The spikes will be in the order of the given spike trains and ``t_start`` and ``t_stop`` will be set to the minimum and maximum value. :rtype: :class:`neo.core.SpikeTrain` """ t_start, t_stop = maximum_spike_train_interval({0: trains}) return neo.SpikeTrain( spq.concatenate([train.view(type=pq.Quantity) for train in trains]), t_start=t_start, t_stop=t_stop)