def test__children(self):
params = {'test2': 'y1', 'test3': True}
evt = Event([1.1, 1.5, 1.7] * pq.ms,
labels=np.array(
['test event 1', 'test event 2', 'test event 3'],
dtype='S'),
name='test',
description='tester',
file_origin='test.file',
test1=1,
**params)
evt.annotate(test1=1.1, test0=[1, 2])
assert_neo_object_is_compliant(evt)
segment = Segment(name='seg1')
segment.events = [evt]
segment.create_many_to_one_relationship()
self.assertEqual(evt._single_parent_objects, ('Segment', ))
self.assertEqual(evt._multi_parent_objects, ())
self.assertEqual(evt._single_parent_containers, ('segment', ))
self.assertEqual(evt._multi_parent_containers, ())
self.assertEqual(evt._parent_objects, ('Segment', ))
self.assertEqual(evt._parent_containers, ('segment', ))
self.assertEqual(len(evt.parents), 1)
self.assertEqual(evt.parents[0].name, 'seg1')
assert_neo_object_is_compliant(evt)
def prune_segment(segment: Segment) -> None:
segment.analogsignals = [a for a in segment.analogsignals if "type_id" in a.annotations]
segment.epochs = [ep for ep in segment.epochs if "type_id" in ep.annotations]
segment.events = [ev for ev in segment.events if "type_id" in ev.annotations]
segment.irregularlysampledsignals = [i for i in segment.irregularlysampledsignals if "type_id" in i.annotations]
segment.spiketrains = [st for st in segment.spiketrains if "type_id" in st.annotations]
segment.imagesequences = [i for i in segment.imagesequences if "type_id" in i.annotations]
def test__add_epoch(self):
starts = Event(times=[0.5, 10.0, 25.2] * pq.s)
starts.annotate(event_type='trial start')
starts.array_annotate(trial_id=[1, 2, 3])
stops = Event(times=[5.5, 14.9, 30.1] * pq.s)
stops.annotate(event_type='trial stop')
stops.array_annotate(trial_id=[1, 2, 3])
seg = Segment()
seg.events = [starts, stops]
# test cutting with one event only
ep_starts = add_epoch(seg, starts, pre=-300 * pq.ms, post=250 * pq.ms)
assert_neo_object_is_compliant(ep_starts)
assert_same_annotations(ep_starts, starts)
assert_arrays_almost_equal(ep_starts.times, starts.times - 300 * pq.ms,
1e-12)
assert_arrays_almost_equal(
ep_starts.durations,
(550 * pq.ms).rescale(ep_starts.durations.units) * np.ones(
(len(starts))), 1e-12)
# test cutting with two events
ep_trials = add_epoch(seg, starts, stops)
assert_neo_object_is_compliant(ep_trials)
assert_same_annotations(ep_trials, starts)
assert_arrays_almost_equal(ep_trials.times, starts.times, 1e-12)
assert_arrays_almost_equal(ep_trials.durations, stops - starts, 1e-12)
def test__add_epoch(self):
proxy_event = EventProxy(rawio=self.reader,
event_channel_index=0,
block_index=0,
seg_index=0)
loaded_event = proxy_event.load()
regular_event = Event(times=loaded_event.times -
1 * loaded_event.units)
loaded_event.annotate(nix_name='neo.event.0')
regular_event.annotate(nix_name='neo.event.1')
seg = Segment()
seg.events = [regular_event, proxy_event]
# test cutting with two events one of which is a proxy
epoch = add_epoch(seg, regular_event, proxy_event)
assert_neo_object_is_compliant(epoch)
exp_annos = {
k: v
for k, v in regular_event.annotations.items() if k != 'nix_name'
}
self.assertDictEqual(epoch.annotations, exp_annos)
assert_arrays_almost_equal(epoch.times, regular_event.times, 1e-12)
assert_arrays_almost_equal(
epoch.durations,
np.ones(regular_event.shape) * loaded_event.units, 1e-12)
def test__children(self):
params = {'test2': 'y1', 'test3': True}
evt = Event([1.1, 1.5, 1.7]*pq.ms,
labels=np.array(['test event 1',
'test event 2',
'test event 3'], dtype='S'),
name='test', description='tester',
file_origin='test.file',
test1=1, **params)
evt.annotate(test1=1.1, test0=[1, 2])
assert_neo_object_is_compliant(evt)
segment = Segment(name='seg1')
segment.events = [evt]
segment.create_many_to_one_relationship()
self.assertEqual(evt._single_parent_objects, ('Segment',))
self.assertEqual(evt._multi_parent_objects, ())
self.assertEqual(evt._single_parent_containers, ('segment',))
self.assertEqual(evt._multi_parent_containers, ())
self.assertEqual(evt._parent_objects, ('Segment',))
self.assertEqual(evt._parent_containers, ('segment',))
self.assertEqual(len(evt.parents), 1)
self.assertEqual(evt.parents[0].name, 'seg1')
assert_neo_object_is_compliant(evt)
def test__children(self):
params = {"test2": "y1", "test3": True}
evt = Event(
1.5 * pq.ms,
label="test epoch",
name="test",
description="tester",
file_origin="test.file",
test1=1,
**params
)
evt.annotate(test1=1.1, test0=[1, 2])
assert_neo_object_is_compliant(evt)
segment = Segment(name="seg1")
segment.events = [evt]
segment.create_many_to_one_relationship()
self.assertEqual(evt._single_parent_objects, ("Segment",))
self.assertEqual(evt._multi_parent_objects, ())
self.assertEqual(evt._single_parent_containers, ("segment",))
self.assertEqual(evt._multi_parent_containers, ())
self.assertEqual(evt._parent_objects, ("Segment",))
self.assertEqual(evt._parent_containers, ("segment",))
self.assertEqual(len(evt.parents), 1)
self.assertEqual(evt.parents[0].name, "seg1")
assert_neo_object_is_compliant(evt)
def test__get_events(self):
starts_1 = Event(times=[0.5, 10.0, 25.2] * pq.s)
starts_1.annotate(event_type='trial start', pick='me')
starts_1.array_annotate(trial_id=[1, 2, 3])
stops_1 = Event(times=[5.5, 14.9, 30.1] * pq.s)
stops_1.annotate(event_type='trial stop')
stops_1.array_annotate(trial_id=[1, 2, 3])
proxy_event = EventProxy(rawio=self.reader,
event_channel_index=0,
block_index=0,
seg_index=0)
proxy_event.annotate(event_type='trial start')
seg = Segment()
seg.events = [starts_1, stops_1, proxy_event]
# test getting multiple events including a proxy
extracted_starts = get_events(seg, event_type='trial start')
self.assertEqual(len(extracted_starts), 2)
# make sure the event is loaded and a neo.Event object is returned
self.assertTrue(isinstance(extracted_starts[0], Event))
self.assertTrue(isinstance(extracted_starts[1], Event))
def _read_segment(self, node, parent):
attributes = self._get_standard_attributes(node)
segment = Segment(**attributes)
signals = []
for name, child_node in node['analogsignals'].items():
if "AnalogSignal" in name:
signals.append(self._read_analogsignal(child_node, parent=segment))
if signals and self.merge_singles:
segment.unmerged_analogsignals = signals # signals will be merged later
signals = []
for name, child_node in node['analogsignalarrays'].items():
if "AnalogSignalArray" in name:
signals.append(self._read_analogsignalarray(child_node, parent=segment))
segment.analogsignals = signals
irr_signals = []
for name, child_node in node['irregularlysampledsignals'].items():
if "IrregularlySampledSignal" in name:
irr_signals.append(self._read_irregularlysampledsignal(child_node, parent=segment))
if irr_signals and self.merge_singles:
segment.unmerged_irregularlysampledsignals = irr_signals
irr_signals = []
segment.irregularlysampledsignals = irr_signals
epochs = []
for name, child_node in node['epochs'].items():
if "Epoch" in name:
epochs.append(self._read_epoch(child_node, parent=segment))
if self.merge_singles:
epochs = self._merge_data_objects(epochs)
for name, child_node in node['epocharrays'].items():
if "EpochArray" in name:
epochs.append(self._read_epocharray(child_node, parent=segment))
segment.epochs = epochs
events = []
for name, child_node in node['events'].items():
if "Event" in name:
events.append(self._read_event(child_node, parent=segment))
if self.merge_singles:
events = self._merge_data_objects(events)
for name, child_node in node['eventarrays'].items():
if "EventArray" in name:
events.append(self._read_eventarray(child_node, parent=segment))
segment.events = events
spiketrains = []
for name, child_node in node['spikes'].items():
raise NotImplementedError('Spike objects not yet handled.')
for name, child_node in node['spiketrains'].items():
if "SpikeTrain" in name:
spiketrains.append(self._read_spiketrain(child_node, parent=segment))
segment.spiketrains = spiketrains
segment.block = parent
return segment
def _read_segment(self, node, parent):
attributes = self._get_standard_attributes(node)
segment = Segment(**attributes)
signals = []
for name, child_node in node['analogsignals'].items():
if "AnalogSignal" in name:
signals.append(self._read_analogsignal(child_node, parent=segment))
if signals and self.merge_singles:
segment.unmerged_analogsignals = signals # signals will be merged later
signals = []
for name, child_node in node['analogsignalarrays'].items():
if "AnalogSignalArray" in name:
signals.append(self._read_analogsignalarray(child_node, parent=segment))
segment.analogsignals = signals
irr_signals = []
for name, child_node in node['irregularlysampledsignals'].items():
if "IrregularlySampledSignal" in name:
irr_signals.append(self._read_irregularlysampledsignal(child_node, parent=segment))
if irr_signals and self.merge_singles:
segment.unmerged_irregularlysampledsignals = irr_signals
irr_signals = []
segment.irregularlysampledsignals = irr_signals
epochs = []
for name, child_node in node['epochs'].items():
if "Epoch" in name:
epochs.append(self._read_epoch(child_node, parent=segment))
if self.merge_singles:
epochs = self._merge_data_objects(epochs)
for name, child_node in node['epocharrays'].items():
if "EpochArray" in name:
epochs.append(self._read_epocharray(child_node, parent=segment))
segment.epochs = epochs
events = []
for name, child_node in node['events'].items():
if "Event" in name:
events.append(self._read_event(child_node, parent=segment))
if self.merge_singles:
events = self._merge_data_objects(events)
for name, child_node in node['eventarrays'].items():
if "EventArray" in name:
events.append(self._read_eventarray(child_node, parent=segment))
segment.events = events
spiketrains = []
for name, child_node in node['spikes'].items():
raise NotImplementedError('Spike objects not yet handled.')
for name, child_node in node['spiketrains'].items():
if "SpikeTrain" in name:
spiketrains.append(self._read_spiketrain(child_node, parent=segment))
segment.spiketrains = spiketrains
segment.block = parent
return segment
def test__match_events(self):
proxy_event = EventProxy(rawio=self.reader, event_channel_index=0,
block_index=0, seg_index=0)
loaded_event = proxy_event.load()
regular_event = Event(times=loaded_event.times - 1 * loaded_event.units,
labels=np.array(['trigger_a', 'trigger_b'] * 3, dtype='U12'))
seg = Segment()
seg.events = [regular_event, proxy_event]
# test matching two events one of which is a proxy
matched_regular, matched_proxy = match_events(regular_event, proxy_event)
assert_same_attributes(matched_regular, regular_event)
assert_same_attributes(matched_proxy, loaded_event)
def test__children(self):
params = {'testarg2': 'yes', 'testarg3': True}
evt = Event(1.5 * pq.ms,
label='test epoch',
name='test',
description='tester',
file_origin='test.file',
testarg1=1,
**params)
evt.annotate(testarg1=1.1, testarg0=[1, 2, 3])
assert_neo_object_is_compliant(evt)
segment = Segment(name='seg1')
segment.events = [evt]
segment.create_many_to_one_relationship()
self.assertEqual(evt._container_child_objects, ())
self.assertEqual(evt._data_child_objects, ())
self.assertEqual(evt._single_parent_objects, ('Segment', ))
self.assertEqual(evt._multi_child_objects, ())
self.assertEqual(evt._multi_parent_objects, ())
self.assertEqual(evt._child_properties, ())
self.assertEqual(evt._single_child_objects, ())
self.assertEqual(evt._container_child_containers, ())
self.assertEqual(evt._data_child_containers, ())
self.assertEqual(evt._single_child_containers, ())
self.assertEqual(evt._single_parent_containers, ('segment', ))
self.assertEqual(evt._multi_child_containers, ())
self.assertEqual(evt._multi_parent_containers, ())
self.assertEqual(evt._child_objects, ())
self.assertEqual(evt._child_containers, ())
self.assertEqual(evt._parent_objects, ('Segment', ))
self.assertEqual(evt._parent_containers, ('segment', ))
self.assertEqual(evt.children, ())
self.assertEqual(len(evt.parents), 1)
self.assertEqual(evt.parents[0].name, 'seg1')
evt.create_many_to_one_relationship()
evt.create_many_to_many_relationship()
evt.create_relationship()
assert_neo_object_is_compliant(evt)
def test__add_epoch(self):
proxy_event = EventProxy(rawio=self.reader, event_channel_index=0,
block_index=0, seg_index=0)
loaded_event = proxy_event.load()
regular_event = Event(times=loaded_event.times - 1 * loaded_event.units)
seg = Segment()
seg.events = [regular_event, proxy_event]
# test cutting with two events one of which is a proxy
epoch = add_epoch(seg, regular_event, proxy_event)
assert_neo_object_is_compliant(epoch)
assert_same_annotations(epoch, regular_event)
assert_arrays_almost_equal(epoch.times, regular_event.times, 1e-12)
assert_arrays_almost_equal(epoch.durations,
np.ones(regular_event.shape) * loaded_event.units, 1e-12)
def test__children(self):
params = {'testarg2': 'yes', 'testarg3': True}
evt = Event(1.5*pq.ms,
label='test epoch', name='test', description='tester',
file_origin='test.file',
testarg1=1, **params)
evt.annotate(testarg1=1.1, testarg0=[1, 2, 3])
assert_neo_object_is_compliant(evt)
segment = Segment(name='seg1')
segment.events = [evt]
segment.create_many_to_one_relationship()
self.assertEqual(evt._container_child_objects, ())
self.assertEqual(evt._data_child_objects, ())
self.assertEqual(evt._single_parent_objects, ('Segment',))
self.assertEqual(evt._multi_child_objects, ())
self.assertEqual(evt._multi_parent_objects, ())
self.assertEqual(evt._child_properties, ())
self.assertEqual(evt._single_child_objects, ())
self.assertEqual(evt._container_child_containers, ())
self.assertEqual(evt._data_child_containers, ())
self.assertEqual(evt._single_child_containers, ())
self.assertEqual(evt._single_parent_containers, ('segment',))
self.assertEqual(evt._multi_child_containers, ())
self.assertEqual(evt._multi_parent_containers, ())
self.assertEqual(evt._child_objects, ())
self.assertEqual(evt._child_containers, ())
self.assertEqual(evt._parent_objects, ('Segment',))
self.assertEqual(evt._parent_containers, ('segment',))
self.assertEqual(evt.children, ())
self.assertEqual(len(evt.parents), 1)
self.assertEqual(evt.parents[0].name, 'seg1')
evt.create_many_to_one_relationship()
evt.create_many_to_many_relationship()
evt.create_relationship()
assert_neo_object_is_compliant(evt)
def proc_src_comments(srcfile, filename):
'''Get the comments in an src file that has been#!N
processed by the official
matlab function. See proc_src for details'''
comm_seg = Segment(name='Comments', file_origin=filename)
commentarray = srcfile['comments'].flatten()[0]
senders = [res[0] for res in commentarray['sender'].flatten()]
texts = [res[0] for res in commentarray['text'].flatten()]
timeStamps = [res[0, 0] for res in commentarray['timeStamp'].flatten()]
timeStamps = np.array(timeStamps, dtype=np.float32)
t_start = timeStamps.min()
timeStamps = pq.Quantity(timeStamps - t_start, units=pq.d).rescale(pq.s)
texts = np.array(texts, dtype='S')
senders = np.array(senders, dtype='S')
t_start = brainwaresrcio.convert_brainwaresrc_timestamp(t_start.tolist())
comments = Event(times=timeStamps, labels=texts, senders=senders)
comm_seg.events = [comments]
comm_seg.rec_datetime = t_start
return comm_seg
def proc_src_comments(srcfile, filename):
'''Get the comments in an src file that has been#!N
processed by the official
matlab function. See proc_src for details'''
comm_seg = Segment(name='Comments', file_origin=filename)
commentarray = srcfile['comments'].flatten()[0]
senders = [res[0] for res in commentarray['sender'].flatten()]
texts = [res[0] for res in commentarray['text'].flatten()]
timeStamps = [res[0, 0] for res in commentarray['timeStamp'].flatten()]
timeStamps = np.array(timeStamps, dtype=np.float32)
t_start = timeStamps.min()
timeStamps = pq.Quantity(timeStamps - t_start, units=pq.d).rescale(pq.s)
texts = np.array(texts, dtype='U')
senders = np.array(senders, dtype='S')
t_start = brainwaresrcio.convert_brainwaresrc_timestamp(t_start.tolist())
comments = Event(times=timeStamps, labels=texts, senders=senders)
comm_seg.events = [comments]
comm_seg.rec_datetime = t_start
return comm_seg
def test__get_events(self):
starts_1 = Event(times=[0.5, 10.0, 25.2] * pq.s)
starts_1.annotate(event_type='trial start', pick='me')
starts_1.array_annotate(trial_id=[1, 2, 3])
stops_1 = Event(times=[5.5, 14.9, 30.1] * pq.s)
stops_1.annotate(event_type='trial stop')
stops_1.array_annotate(trial_id=[1, 2, 3])
starts_2 = Event(times=[33.2, 41.7, 52.4] * pq.s)
starts_2.annotate(event_type='trial start')
starts_2.array_annotate(trial_id=[4, 5, 6])
stops_2 = Event(times=[37.6, 46.1, 57.0] * pq.s)
stops_2.annotate(event_type='trial stop')
stops_2.array_annotate(trial_id=[4, 5, 6])
seg = Segment()
seg2 = Segment()
seg.events = [starts_1, stops_1]
seg2.events = [starts_2, stops_2]
block = Block()
block.segments = [seg, seg2]
# test getting one whole event via annotation
extracted_starts1 = get_events(seg, event_type='trial start')
extracted_starts1b = get_events(block, pick='me')
self.assertEqual(len(extracted_starts1), 1)
self.assertEqual(len(extracted_starts1b), 1)
extracted_starts1 = extracted_starts1[0]
extracted_starts1b = extracted_starts1b[0]
assert_same_attributes(extracted_starts1, starts_1)
assert_same_attributes(extracted_starts1b, starts_1)
# test getting an empty list by searching for a non-existent property
empty1 = get_events(seg, foo='bar')
self.assertEqual(len(empty1), 0)
# test getting an empty list by searching for a non-existent property value
empty2 = get_events(seg, event_type='undefined')
self.assertEqual(len(empty2), 0)
# test getting only one event time of one event
trial_2 = get_events(block, trial_id=2, event_type='trial start')
self.assertEqual(len(trial_2), 1)
trial_2 = trial_2[0]
self.assertEqual(starts_1.name, trial_2.name)
self.assertEqual(starts_1.description, trial_2.description)
self.assertEqual(starts_1.file_origin, trial_2.file_origin)
self.assertEqual(starts_1.annotations['event_type'],
trial_2.annotations['event_type'])
assert_arrays_equal(trial_2.array_annotations['trial_id'],
np.array([2]))
self.assertIsInstance(trial_2.array_annotations, ArrayDict)
# test getting only one event time of more than one event
trial_2b = get_events(block, trial_id=2)
self.assertEqual(len(trial_2b), 2)
start_idx = np.where(
np.array([ev.annotations['event_type']
for ev in trial_2b]) == 'trial start')[0][0]
trial_2b_start = trial_2b[start_idx]
trial_2b_stop = trial_2b[start_idx - 1]
assert_same_attributes(trial_2b_start, trial_2)
self.assertEqual(stops_1.name, trial_2b_stop.name)
self.assertEqual(stops_1.description, trial_2b_stop.description)
self.assertEqual(stops_1.file_origin, trial_2b_stop.file_origin)
self.assertEqual(stops_1.annotations['event_type'],
trial_2b_stop.annotations['event_type'])
assert_arrays_equal(trial_2b_stop.array_annotations['trial_id'],
np.array([2]))
self.assertIsInstance(trial_2b_stop.array_annotations, ArrayDict)
# test getting more than one event time of one event
trials_1_2 = get_events(block,
trial_id=[1, 2],
event_type='trial start')
self.assertEqual(len(trials_1_2), 1)
trials_1_2 = trials_1_2[0]
self.assertEqual(starts_1.name, trials_1_2.name)
self.assertEqual(starts_1.description, trials_1_2.description)
self.assertEqual(starts_1.file_origin, trials_1_2.file_origin)
self.assertEqual(starts_1.annotations['event_type'],
trials_1_2.annotations['event_type'])
assert_arrays_equal(trials_1_2.array_annotations['trial_id'],
np.array([1, 2]))
self.assertIsInstance(trials_1_2.array_annotations, ArrayDict)
# test getting more than one event time of more than one event
trials_1_2b = get_events(block, trial_id=[1, 2])
self.assertEqual(len(trials_1_2b), 2)
start_idx = np.where(
np.array([ev.annotations['event_type']
for ev in trials_1_2b]) == 'trial start')[0][0]
trials_1_2b_start = trials_1_2b[start_idx]
trials_1_2b_stop = trials_1_2b[start_idx - 1]
assert_same_attributes(trials_1_2b_start, trials_1_2)
self.assertEqual(stops_1.name, trials_1_2b_stop.name)
self.assertEqual(stops_1.description, trials_1_2b_stop.description)
self.assertEqual(stops_1.file_origin, trials_1_2b_stop.file_origin)
self.assertEqual(stops_1.annotations['event_type'],
trials_1_2b_stop.annotations['event_type'])
assert_arrays_equal(trials_1_2b_stop.array_annotations['trial_id'],
np.array([1, 2]))
self.assertIsInstance(trials_1_2b_stop.array_annotations, ArrayDict)
def test__cut_block_by_epochs(self):
epoch = Epoch([0.5, 10.0, 25.2] * pq.s,
durations=[5.1, 4.8, 5.0] * pq.s,
t_start=.1 * pq.s)
epoch.annotate(epoch_type='a', pick='me')
epoch.array_annotate(trial_id=[1, 2, 3])
epoch2 = Epoch([0.6, 9.5, 16.8, 34.1] * pq.s,
durations=[4.5, 4.8, 5.0, 5.0] * pq.s,
t_start=.1 * pq.s)
epoch2.annotate(epoch_type='b')
epoch2.array_annotate(trial_id=[1, 2, 3, 4])
event = Event(times=[0.5, 10.0, 25.2] * pq.s, t_start=.1 * pq.s)
event.annotate(event_type='trial start')
event.array_annotate(trial_id=[1, 2, 3])
anasig = AnalogSignal(np.arange(50.0) * pq.mV,
t_start=.1 * pq.s,
sampling_rate=1.0 * pq.Hz)
irrsig = IrregularlySampledSignal(signal=np.arange(50.0) * pq.mV,
times=anasig.times,
t_start=.1 * pq.s)
st = SpikeTrain(
np.arange(0.5, 50, 7) * pq.s,
t_start=.1 * pq.s,
t_stop=50.0 * pq.s,
waveforms=np.array(
[[[0., 1.], [0.1, 1.1]], [[2., 3.], [2.1, 3.1]],
[[4., 5.], [4.1, 5.1]], [[6., 7.], [6.1, 7.1]],
[[8., 9.], [8.1, 9.1]], [[12., 13.], [12.1, 13.1]],
[[14., 15.], [14.1, 15.1]], [[16., 17.], [16.1, 17.1]]]) *
pq.mV,
array_annotations={'spikenum': np.arange(1, 9)})
seg = Segment()
seg2 = Segment(name='NoCut')
seg.epochs = [epoch, epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg, seg2]
block.create_many_to_one_relationship()
# test without resetting the time
cut_block_by_epochs(block, properties={'pick': 'me'})
assert_neo_object_is_compliant(block)
self.assertEqual(len(block.segments), 3)
for epoch_idx in range(len(epoch)):
self.assertEqual(len(block.segments[epoch_idx].events), 1)
self.assertEqual(len(block.segments[epoch_idx].spiketrains), 1)
self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
self.assertEqual(
len(block.segments[epoch_idx].irregularlysampledsignals), 1)
if epoch_idx != 0:
self.assertEqual(len(block.segments[epoch_idx].epochs), 1)
else:
self.assertEqual(len(block.segments[epoch_idx].epochs), 2)
assert_same_attributes(
block.segments[epoch_idx].spiketrains[0],
st.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[epoch_idx].analogsignals[0],
anasig.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[epoch_idx].irregularlysampledsignals[0],
irrsig.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[epoch_idx].events[0],
event.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[0].epochs[0],
epoch.time_slice(t_start=epoch.times[0],
t_stop=epoch.times[0] + epoch.durations[0]))
assert_same_attributes(
block.segments[0].epochs[1],
epoch2.time_slice(t_start=epoch.times[0],
t_stop=epoch.times[0] + epoch.durations[0]))
seg = Segment()
seg2 = Segment(name='NoCut')
seg.epochs = [epoch, epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg, seg2]
block.create_many_to_one_relationship()
# test with resetting the time
cut_block_by_epochs(block, properties={'pick': 'me'}, reset_time=True)
assert_neo_object_is_compliant(block)
self.assertEqual(len(block.segments), 3)
for epoch_idx in range(len(epoch)):
self.assertEqual(len(block.segments[epoch_idx].events), 1)
self.assertEqual(len(block.segments[epoch_idx].spiketrains), 1)
self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
self.assertEqual(
len(block.segments[epoch_idx].irregularlysampledsignals), 1)
if epoch_idx != 0:
self.assertEqual(len(block.segments[epoch_idx].epochs), 1)
else:
self.assertEqual(len(block.segments[epoch_idx].epochs), 2)
assert_same_attributes(
block.segments[epoch_idx].spiketrains[0],
st.time_shift(-epoch.times[epoch_idx]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx]))
anasig_target = anasig.time_shift(-epoch.times[epoch_idx])
anasig_target = anasig_target.time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx])
assert_same_attributes(block.segments[epoch_idx].analogsignals[0],
anasig_target)
irrsig_target = irrsig.time_shift(-epoch.times[epoch_idx])
irrsig_target = irrsig_target.time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx])
assert_same_attributes(
block.segments[epoch_idx].irregularlysampledsignals[0],
irrsig_target)
assert_same_attributes(
block.segments[epoch_idx].events[0],
event.time_shift(-epoch.times[epoch_idx]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[0].epochs[0],
epoch.time_shift(-epoch.times[0]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[0]))
assert_same_attributes(
block.segments[0].epochs[1],
epoch2.time_shift(-epoch.times[0]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[0]))
