full_spike_train = sorting2.get_unit_spike_train(unit_id=1)
firing_rate = float(len(full_spike_train)) / sorting2.get_sampling_frequency()
sorting2.set_unit_property(unit_id=1,
property_name='firing_rate',
value=firing_rate)
print('Average firing rate during the recording of unit 1 = {}'.format(
sorting2.get_unit_property(unit_id=1, property_name='firing_rate')))
print("Spike property names: " +
str(sorting2.get_shared_unit_property_names()))
##############################################################################
# :code:`SubSortingExtractor` objects can be used to extract arbitrary subsets of your units/spike trains manually
sorting3 = se.SubSortingExtractor(parent_sorting=sorting2,
unit_ids=[1, 2],
start_frame=10000,
end_frame=20000)
print('Num. units = {}'.format(len(sorting3.get_unit_ids())))
print('Average firing rate of units1 during frames 10000-20000 = {}'.format(
float(len(sorting3.get_unit_spike_train(unit_id=1))) / 6000))
##############################################################################
# Unit features are name value pairs that we can store for each spike. Let's load a randomly generated 'random_value'
# features. Features are used, for example, to store waveforms, amplitude, and PCA scores
random_values = np.random.randn(len(sorting3.get_unit_spike_train(unit_id=1)))
sorting3.set_unit_spike_features(unit_id=1,
feature_name='random_value',
value=random_values)
print("Spike feature names: " +
str(sorting3.get_shared_unit_spike_feature_names()))
recordings_list.append(recording_single)
##############################################################################
# We can now use the :code:`recordings_list` to instantiate a :code:`MultiRecordingTimeExtractor`, which concatenates
# the traces in time:
multirecording = se.MultiRecordingTimeExtractor(recordings=recordings_list)
##############################################################################
# Since the :code:`MultiRecordingTimeExtractor` is a :code:`RecordingExtractor`, we can run spike sorting "normally"
multisorting = ss.run_klusta(multirecording)
##############################################################################
# The returned :code:`multisorting` object is a normal :code:`SortingExtractor`, but we now that its spike trains are
# concatenated similarly to the recording concatenation. So we have to split them back. We can do that using the `epoch`
# information in the :code:`MultiRecordingTimeExtractor`:
sortings = []
sortings = []
for epoch in multirecording.get_epoch_names():
info = multirecording.get_epoch_info(epoch)
sorting_single = se.SubSortingExtractor(multisorting, start_frame=info['start_frame'], end_frame=info['end_frame'])
sortings.append(sorting_single)
##############################################################################
# The :code:`SortingExtractor` objects in the :code:`sortings` list contain now split spike trains. The nice thing of
# this approach is that the unit_ids for the different epochs are the same unit!