def _read_main_pulse_file(filepaths: List[str]) -> Event:
try:
# read pulse file
pulse_file = [
file for file in filepaths
if "pulses" in os.path.basename(file).lower()
][0]
pulses_df = pd.read_csv(filepath_or_buffer=pulse_file,
header=None,
names=["timestamp", "comment"])
times = Quantity(pulses_df["timestamp"], "s")
pulses = Event(times=times,
labels=pulses_df["comment"],
name="Dapsys Main Pulse",
file_origin=pulse_file)
channel_id = f"{TypeID.ELECTRICAL_STIMULUS.value}.0"
pulses.annotate(id=channel_id,
type_id=TypeID.ELECTRICAL_STIMULUS.value)
intervals: Quantity = np.diff(times)
intervals = quantity_concat(intervals,
np.array([float("inf")]) * second)
pulses.array_annotate(intervals=intervals)
return pulses
except Exception as ex:
traceback.print_exc()
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 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 create_all_annotated(cls):
times = cls.rquant(1, pq.s)
signal = cls.rquant(1, pq.V)
blk = Block()
blk.annotate(**cls.rdict(3))
cls.populate_dates(blk)
seg = Segment()
seg.annotate(**cls.rdict(4))
cls.populate_dates(seg)
blk.segments.append(seg)
asig = AnalogSignal(signal=signal, sampling_rate=pq.Hz)
asig.annotate(**cls.rdict(2))
seg.analogsignals.append(asig)
isig = IrregularlySampledSignal(times=times,
signal=signal,
time_units=pq.s)
isig.annotate(**cls.rdict(2))
seg.irregularlysampledsignals.append(isig)
epoch = Epoch(times=times, durations=times)
epoch.annotate(**cls.rdict(4))
seg.epochs.append(epoch)
event = Event(times=times)
event.annotate(**cls.rdict(4))
seg.events.append(event)
spiketrain = SpikeTrain(times=times, t_stop=pq.s, units=pq.s)
d = cls.rdict(6)
d["quantity"] = pq.Quantity(10, "mV")
d["qarray"] = pq.Quantity(range(10), "mA")
spiketrain.annotate(**d)
seg.spiketrains.append(spiketrain)
chx = ChannelIndex(name="achx", index=[1, 2], channel_ids=[0, 10])
chx.annotate(**cls.rdict(5))
blk.channel_indexes.append(chx)
unit = Unit()
unit.annotate(**cls.rdict(2))
chx.units.append(unit)
return blk
def create_all_annotated(cls):
times = cls.rquant(1, pq.s)
signal = cls.rquant(1, pq.V)
blk = Block()
blk.annotate(**cls.rdict(3))
seg = Segment()
seg.annotate(**cls.rdict(4))
blk.segments.append(seg)
asig = AnalogSignal(signal=signal, sampling_rate=pq.Hz)
asig.annotate(**cls.rdict(2))
seg.analogsignals.append(asig)
isig = IrregularlySampledSignal(times=times, signal=signal,
time_units=pq.s)
isig.annotate(**cls.rdict(2))
seg.irregularlysampledsignals.append(isig)
epoch = Epoch(times=times, durations=times)
epoch.annotate(**cls.rdict(4))
seg.epochs.append(epoch)
event = Event(times=times)
event.annotate(**cls.rdict(4))
seg.events.append(event)
spiketrain = SpikeTrain(times=times, t_stop=pq.s, units=pq.s)
d = cls.rdict(6)
d["quantity"] = pq.Quantity(10, "mV")
d["qarray"] = pq.Quantity(range(10), "mA")
spiketrain.annotate(**d)
seg.spiketrains.append(spiketrain)
chx = ChannelIndex(name="achx", index=[1, 2], channel_ids=[0, 10])
chx.annotate(**cls.rdict(5))
blk.channel_indexes.append(chx)
unit = Unit()
unit.annotate(**cls.rdict(2))
chx.units.append(unit)
return blk
def test__match_events(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])
stops2 = Event(times=[0.1, 5.5, 5.6, 14.9, 25.2, 30.1] * pq.s)
stops2.annotate(event_type='trial stop')
stops2.array_annotate(trial_id=[1, 1, 2, 2, 3, 3])
# test for matching input events, should just return identical copies
matched_starts, matched_stops = match_events(starts, stops)
assert_same_attributes(matched_starts, starts)
assert_same_attributes(matched_stops, stops)
# test for non-matching input events, should find shortest positive non-zero durations
matched_starts2, matched_stops2 = match_events(starts, stops2)
assert_same_attributes(matched_starts2, starts)
assert_same_attributes(matched_stops2, stops)
def read_one_channel_event_or_spike(self, fid, channel_num, header,
lazy=True):
# return SPikeTrain or Event
channelHeader = header.channelHeaders[channel_num]
if channelHeader.firstblock < 0:
return
if channelHeader.kind not in [2, 3, 4, 5, 6, 7, 8]:
return
# # Step 1 : type of blocks
if channelHeader.kind in [2, 3, 4]:
# Event data
fmt = [('tick', 'i4')]
elif channelHeader.kind in [5]:
# Marker data
fmt = [('tick', 'i4'), ('marker', 'i4')]
elif channelHeader.kind in [6]:
# AdcMark data
fmt = [('tick', 'i4'), ('marker', 'i4'),
('adc', 'S%d' % channelHeader.n_extra)]
elif channelHeader.kind in [7]:
# RealMark data
fmt = [('tick', 'i4'), ('marker', 'i4'),
('real', 'S%d' % channelHeader.n_extra)]
elif channelHeader.kind in [8]:
# TextMark data
fmt = [('tick', 'i4'), ('marker', 'i4'),
('label', 'S%d' % channelHeader.n_extra)]
dt = np.dtype(fmt)
## Step 2 : first read for allocating mem
fid.seek(channelHeader.firstblock)
totalitems = 0
for _ in range(channelHeader.blocks):
blockHeader = HeaderReader(fid, np.dtype(blockHeaderDesciption))
totalitems += blockHeader.items
if blockHeader.succ_block > 0:
fid.seek(blockHeader.succ_block)
#~ print 'totalitems' , totalitems
if lazy:
if channelHeader.kind in [2, 3, 4, 5, 8]:
ea = Event()
ea.annotate(channel_index=channel_num)
ea.lazy_shape = totalitems
return ea
elif channelHeader.kind in [6, 7]:
# correct value for t_stop to be put in later
sptr = SpikeTrain([] * pq.s, t_stop=1e99)
sptr.annotate(channel_index=channel_num, ced_unit = 0)
sptr.lazy_shape = totalitems
return sptr
else:
alltrigs = np.zeros(totalitems, dtype=dt)
## Step 3 : read
fid.seek(channelHeader.firstblock)
pos = 0
for _ in range(channelHeader.blocks):
blockHeader = HeaderReader(
fid, np.dtype(blockHeaderDesciption))
# read all events in block
trigs = np.fromstring(
fid.read(blockHeader.items * dt.itemsize), dtype=dt)
alltrigs[pos:pos + trigs.size] = trigs
pos += trigs.size
if blockHeader.succ_block > 0:
fid.seek(blockHeader.succ_block)
## Step 3 convert in neo standard class: eventarrays or spiketrains
alltimes = alltrigs['tick'].astype(
'f') * header.us_per_time * header.dtime_base * pq.s
if channelHeader.kind in [2, 3, 4, 5, 8]:
#events
ea = Event(alltimes)
ea.annotate(channel_index=channel_num)
if channelHeader.kind >= 5:
# Spike2 marker is closer to label sens of neo
ea.labels = alltrigs['marker'].astype('S32')
if channelHeader.kind == 8:
ea.annotate(extra_labels=alltrigs['label'])
return ea
elif channelHeader.kind in [6, 7]:
# spiketrains
# waveforms
if channelHeader.kind == 6:
waveforms = np.fromstring(alltrigs['adc'].tostring(),
dtype='i2')
waveforms = waveforms.astype(
'f4') * channelHeader.scale / 6553.6 + \
channelHeader.offset
elif channelHeader.kind == 7:
waveforms = np.fromstring(alltrigs['real'].tostring(),
dtype='f4')
if header.system_id >= 6 and channelHeader.interleave > 1:
waveforms = waveforms.reshape(
(alltimes.size, -1, channelHeader.interleave))
waveforms = waveforms.swapaxes(1, 2)
else:
waveforms = waveforms.reshape((alltimes.size, 1, -1))
if header.system_id in [1, 2, 3, 4, 5]:
sample_interval = (channelHeader.divide *
header.us_per_time *
header.time_per_adc) * 1e-6
else:
sample_interval = (channelHeader.l_chan_dvd *
header.us_per_time *
header.dtime_base)
if channelHeader.unit in unit_convert:
unit = pq.Quantity(1, unit_convert[channelHeader.unit])
else:
#print channelHeader.unit
try:
unit = pq.Quantity(1, channelHeader.unit)
except:
unit = pq.Quantity(1, '')
if len(alltimes) > 0:
# can get better value from associated AnalogSignal(s) ?
t_stop = alltimes.max()
else:
t_stop = 0.0
if not self.ced_units:
sptr = SpikeTrain(alltimes,
waveforms = waveforms*unit,
sampling_rate = (1./sample_interval)*pq.Hz,
t_stop = t_stop
)
sptr.annotate(channel_index = channel_num, ced_unit = 0)
return [sptr]
sptrs = []
for i in set(alltrigs['marker'] & 255):
sptr = SpikeTrain(alltimes[alltrigs['marker'] == i],
waveforms = waveforms[alltrigs['marker'] == i]*unit,
sampling_rate = (1./sample_interval)*pq.Hz,
t_stop = t_stop
)
sptr.annotate(channel_index = channel_num, ced_unit = i)
sptrs.append(sptr)
return sptrs
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]))
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__time_slice(self):
time_slice = [.5, 5.6] * pq.s
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()
seg.epochs = [epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test without resetting the time
sliced = seg.time_slice(time_slice[0], time_slice[1])
assert_neo_object_is_compliant(sliced)
self.assertEqual(len(sliced.events), 1)
self.assertEqual(len(sliced.spiketrains), 1)
self.assertEqual(len(sliced.analogsignals), 1)
self.assertEqual(len(sliced.irregularlysampledsignals), 1)
self.assertEqual(len(sliced.epochs), 1)
assert_same_attributes(
sliced.spiketrains[0],
st.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.analogsignals[0],
anasig.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.irregularlysampledsignals[0],
irrsig.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.events[0],
event.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.epochs[0],
epoch2.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
seg = Segment()
seg.epochs = [epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test with resetting the time
sliced = seg.time_slice(time_slice[0], time_slice[1], reset_time=True)
assert_neo_object_is_compliant(sliced)
self.assertEqual(len(sliced.events), 1)
self.assertEqual(len(sliced.spiketrains), 1)
self.assertEqual(len(sliced.analogsignals), 1)
self.assertEqual(len(sliced.irregularlysampledsignals), 1)
self.assertEqual(len(sliced.epochs), 1)
assert_same_attributes(
sliced.spiketrains[0],
st.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s,
t_stop=time_slice[1] -
time_slice[0]))
anasig_target = anasig.copy()
anasig_target = anasig_target.time_shift(-time_slice[0]).time_slice(
t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])
assert_same_attributes(sliced.analogsignals[0], anasig_target)
irrsig_target = irrsig.copy()
irrsig_target = irrsig_target.time_shift(-time_slice[0]).time_slice(
t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])
assert_same_attributes(sliced.irregularlysampledsignals[0],
irrsig_target)
assert_same_attributes(
sliced.events[0],
event.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s,
t_stop=time_slice[1] -
time_slice[0]))
assert_same_attributes(
sliced.epochs[0],
epoch2.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s,
t_stop=time_slice[1] -
time_slice[0]))
seg = Segment()
reader = ExampleRawIO(filename='my_filename.fake')
reader.parse_header()
proxy_anasig = AnalogSignalProxy(rawio=reader,
stream_index=0,
inner_stream_channels=None,
block_index=0,
seg_index=0)
seg.analogsignals.append(proxy_anasig)
proxy_st = SpikeTrainProxy(rawio=reader,
spike_channel_index=0,
block_index=0,
seg_index=0)
seg.spiketrains.append(proxy_st)
proxy_event = EventProxy(rawio=reader,
event_channel_index=0,
block_index=0,
seg_index=0)
seg.events.append(proxy_event)
proxy_epoch = EpochProxy(rawio=reader,
event_channel_index=1,
block_index=0,
seg_index=0)
proxy_epoch.annotate(pick='me')
seg.epochs.append(proxy_epoch)
loaded_epoch = proxy_epoch.load()
loaded_event = proxy_event.load()
loaded_st = proxy_st.load()
loaded_anasig = proxy_anasig.load()
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test with proxy objects
sliced = seg.time_slice(time_slice[0], time_slice[1])
assert_neo_object_is_compliant(sliced)
sliced_event = loaded_event.time_slice(t_start=time_slice[0],
t_stop=time_slice[1])
has_event = len(sliced_event) > 0
sliced_anasig = loaded_anasig.time_slice(t_start=time_slice[0],
t_stop=time_slice[1])
sliced_st = loaded_st.time_slice(t_start=time_slice[0],
t_stop=time_slice[1])
self.assertEqual(len(sliced.events), int(has_event))
self.assertEqual(len(sliced.spiketrains), 1)
self.assertEqual(len(sliced.analogsignals), 1)
self.assertTrue(isinstance(sliced.spiketrains[0], SpikeTrain))
assert_same_attributes(sliced.spiketrains[0], sliced_st)
self.assertTrue(isinstance(sliced.analogsignals[0], AnalogSignal))
assert_same_attributes(sliced.analogsignals[0], sliced_anasig)
if has_event:
self.assertTrue(isinstance(sliced.events[0], Event))
assert_same_attributes(sliced.events[0], sliced_event)
def read_one_channel_event_or_spike(self,
fid,
channel_num,
header,
lazy=True):
# return SPikeTrain or Event
channelHeader = header.channelHeaders[channel_num]
if channelHeader.firstblock < 0:
return
if channelHeader.kind not in [2, 3, 4, 5, 6, 7, 8]:
return
# # Step 1 : type of blocks
if channelHeader.kind in [2, 3, 4]:
# Event data
fmt = [('tick', 'i4')]
elif channelHeader.kind in [5]:
# Marker data
fmt = [('tick', 'i4'), ('marker', 'i4')]
elif channelHeader.kind in [6]:
# AdcMark data
fmt = [('tick', 'i4'), ('marker', 'i4'),
('adc', 'S%d' % channelHeader.n_extra)]
elif channelHeader.kind in [7]:
# RealMark data
fmt = [('tick', 'i4'), ('marker', 'i4'),
('real', 'S%d' % channelHeader.n_extra)]
elif channelHeader.kind in [8]:
# TextMark data
fmt = [('tick', 'i4'), ('marker', 'i4'),
('label', 'S%d' % channelHeader.n_extra)]
dt = np.dtype(fmt)
## Step 2 : first read for allocating mem
fid.seek(channelHeader.firstblock)
totalitems = 0
for _ in range(channelHeader.blocks):
blockHeader = HeaderReader(fid, np.dtype(blockHeaderDesciption))
totalitems += blockHeader.items
if blockHeader.succ_block > 0:
fid.seek(blockHeader.succ_block)
#~ print 'totalitems' , totalitems
if lazy:
if channelHeader.kind in [2, 3, 4, 5, 8]:
ea = Event()
ea.annotate(channel_index=channel_num)
ea.lazy_shape = totalitems
return ea
elif channelHeader.kind in [6, 7]:
# correct value for t_stop to be put in later
sptr = SpikeTrain([] * pq.s, t_stop=1e99)
sptr.annotate(channel_index=channel_num, ced_unit=0)
sptr.lazy_shape = totalitems
return sptr
else:
alltrigs = np.zeros(totalitems, dtype=dt)
## Step 3 : read
fid.seek(channelHeader.firstblock)
pos = 0
for _ in range(channelHeader.blocks):
blockHeader = HeaderReader(fid,
np.dtype(blockHeaderDesciption))
# read all events in block
trigs = np.fromstring(fid.read(blockHeader.items *
dt.itemsize),
dtype=dt)
alltrigs[pos:pos + trigs.size] = trigs
pos += trigs.size
if blockHeader.succ_block > 0:
fid.seek(blockHeader.succ_block)
## Step 3 convert in neo standard class: eventarrays or spiketrains
alltimes = alltrigs['tick'].astype(
'f') * header.us_per_time * header.dtime_base * pq.s
if channelHeader.kind in [2, 3, 4, 5, 8]:
#events
ea = Event(alltimes)
ea.annotate(channel_index=channel_num)
if channelHeader.kind >= 5:
# Spike2 marker is closer to label sens of neo
ea.labels = alltrigs['marker'].astype('S32')
if channelHeader.kind == 8:
ea.annotate(extra_labels=alltrigs['label'])
return ea
elif channelHeader.kind in [6, 7]:
# spiketrains
# waveforms
if channelHeader.kind == 6:
waveforms = np.fromstring(alltrigs['adc'].tostring(),
dtype='i2')
waveforms = waveforms.astype(
'f4') * channelHeader.scale / 6553.6 + \
channelHeader.offset
elif channelHeader.kind == 7:
waveforms = np.fromstring(alltrigs['real'].tostring(),
dtype='f4')
if header.system_id >= 6 and channelHeader.interleave > 1:
waveforms = waveforms.reshape(
(alltimes.size, -1, channelHeader.interleave))
waveforms = waveforms.swapaxes(1, 2)
else:
waveforms = waveforms.reshape((alltimes.size, 1, -1))
if header.system_id in [1, 2, 3, 4, 5]:
sample_interval = (channelHeader.divide *
header.us_per_time *
header.time_per_adc) * 1e-6
else:
sample_interval = (channelHeader.l_chan_dvd *
header.us_per_time * header.dtime_base)
if channelHeader.unit in unit_convert:
unit = pq.Quantity(1, unit_convert[channelHeader.unit])
else:
#print channelHeader.unit
try:
unit = pq.Quantity(1, channelHeader.unit)
except:
unit = pq.Quantity(1, '')
if len(alltimes) > 0:
# can get better value from associated AnalogSignal(s) ?
t_stop = alltimes.max()
else:
t_stop = 0.0
if not self.ced_units:
sptr = SpikeTrain(alltimes,
waveforms=waveforms * unit,
sampling_rate=(1. / sample_interval) *
pq.Hz,
t_stop=t_stop)
sptr.annotate(channel_index=channel_num, ced_unit=0)
return [sptr]
sptrs = []
for i in set(alltrigs['marker'] & 255):
sptr = SpikeTrain(
alltimes[alltrigs['marker'] == i],
waveforms=waveforms[alltrigs['marker'] == i] * unit,
sampling_rate=(1. / sample_interval) * pq.Hz,
t_stop=t_stop)
sptr.annotate(channel_index=channel_num, ced_unit=i)
sptrs.append(sptr)
return sptrs