def _read_irregularlysampledsignal(self, node, parent):
attributes = self._get_standard_attributes(node)
signal = IrregularlySampledSignal(times=self._get_quantity(node["times"]),
signal=self._get_quantity(node["signal"]),
**attributes)
signal.segment = parent
return signal
def _read_irregularlysampledsignal(self, node, parent):
attributes = self._get_standard_attributes(node)
signal = IrregularlySampledSignal(times=self._get_quantity(node["times"]),
signal=self._get_quantity(node["signal"]),
**attributes)
signal.segment = parent
return signal
def create_irregularlysampledsignal(self, parent=None, name='IrregularlySampledSignal'):
signal = IrregularlySampledSignal([1.0, 2.3, 6.4] * pq.ms,
[[1, 4], [2, 1], [0, -5]] * pq.mV)
signal.segment = parent
self._assign_basic_attributes(signal, name=name)
return signal
def _read_irregularlysampledsignal(self, node, parent):
attributes = self._get_standard_attributes(node)
signal = IrregularlySampledSignal(times=self._get_quantity(node["times"]),
signal=self._get_quantity(node["signal"]),
**attributes)
signal.segment = parent
if self._lazy:
signal.lazy_shape = node["signal"].shape
if len(signal.lazy_shape) == 1:
signal.lazy_shape = (signal.lazy_shape[0], 1)
return signal
def _read_irregularlysampledsignal(self, node, parent):
attributes = self._get_standard_attributes(node)
signal = IrregularlySampledSignal(
times=self._get_quantity(node["times"]),
signal=self._get_quantity(node["signal"]),
**attributes)
signal.segment = parent
if self._lazy:
signal.lazy_shape = node["signal"].shape
if len(signal.lazy_shape) == 1:
signal.lazy_shape = (signal.lazy_shape[0], 1)
return signal
def test__issue_285(self):
# Spiketrain
train = SpikeTrain([3, 4, 5] * pq.s, t_stop=10.0)
unit = Unit()
train.unit = unit
unit.spiketrains.append(train)
epoch = Epoch(np.array([0, 10, 20]),
np.array([2, 2, 2]),
np.array(["a", "b", "c"]),
units="ms")
blk = Block()
seg = Segment()
seg.spiketrains.append(train)
seg.epochs.append(epoch)
epoch.segment = seg
blk.segments.append(seg)
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.spiketrains[0].unit, Unit)
self.assertIsInstance(r_seg.epochs[0], Epoch)
os.remove('blk.pkl')
# Epoch
epoch = Epoch(times=np.arange(0, 30, 10) * pq.s,
durations=[10, 5, 7] * pq.ms,
labels=np.array(['btn0', 'btn1', 'btn2'], dtype='U'))
epoch.segment = Segment()
blk = Block()
seg = Segment()
seg.epochs.append(epoch)
blk.segments.append(seg)
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.epochs[0].segment, Segment)
os.remove('blk.pkl')
# Event
event = Event(np.arange(0, 30, 10) * pq.s,
labels=np.array(['trig0', 'trig1', 'trig2'], dtype='U'))
event.segment = Segment()
blk = Block()
seg = Segment()
seg.events.append(event)
blk.segments.append(seg)
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.events[0].segment, Segment)
os.remove('blk.pkl')
# IrregularlySampledSignal
signal = IrregularlySampledSignal([0.0, 1.23, 6.78], [1, 2, 3],
units='mV',
time_units='ms')
signal.segment = Segment()
blk = Block()
seg = Segment()
seg.irregularlysampledsignals.append(signal)
blk.segments.append(seg)
blk.segments[0].block = blk
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.irregularlysampledsignals[0].segment,
Segment)
os.remove('blk.pkl')
def test_roundtrip(self):
annotations = {"session_start_time": datetime.now()}
# Define Neo blocks
bl0 = Block(name='First block', **annotations)
bl1 = Block(name='Second block', **annotations)
bl2 = Block(name='Third block', **annotations)
original_blocks = [bl0, bl1, bl2]
num_seg = 4 # number of segments
num_chan = 3 # number of channels
for blk in original_blocks:
for ind in range(num_seg): # number of Segments
seg = Segment(index=ind)
seg.block = blk
blk.segments.append(seg)
for seg in blk.segments: # AnalogSignal objects
# 3 Neo AnalogSignals
a = AnalogSignal(np.random.randn(44, num_chan) * pq.nA,
sampling_rate=10 * pq.kHz,
t_start=50 * pq.ms)
b = AnalogSignal(np.random.randn(64, num_chan) * pq.mV,
sampling_rate=8 * pq.kHz,
t_start=40 * pq.ms)
c = AnalogSignal(np.random.randn(33, num_chan) * pq.uA,
sampling_rate=10 * pq.kHz,
t_start=120 * pq.ms)
# 2 Neo IrregularlySampledSignals
d = IrregularlySampledSignal(
np.arange(7.0) * pq.ms,
np.random.randn(7, num_chan) * pq.mV)
# 2 Neo SpikeTrains
train = SpikeTrain(times=[1, 2, 3] * pq.s,
t_start=1.0,
t_stop=10.0)
train2 = SpikeTrain(times=[4, 5, 6] * pq.s, t_stop=10.0)
# todo: add waveforms
# 1 Neo Event
evt = Event(times=np.arange(0, 30, 10) * pq.ms,
labels=np.array(['ev0', 'ev1', 'ev2']))
# 2 Neo Epochs
epc = Epoch(times=np.arange(0, 30, 10) * pq.s,
durations=[10, 5, 7] * pq.ms,
labels=np.array(['btn0', 'btn1', 'btn2']))
epc2 = Epoch(times=np.arange(10, 40, 10) * pq.s,
durations=[9, 3, 8] * pq.ms,
labels=np.array(['btn3', 'btn4', 'btn5']))
seg.spiketrains.append(train)
seg.spiketrains.append(train2)
seg.epochs.append(epc)
seg.epochs.append(epc2)
seg.analogsignals.append(a)
seg.analogsignals.append(b)
seg.analogsignals.append(c)
seg.irregularlysampledsignals.append(d)
seg.events.append(evt)
a.segment = seg
b.segment = seg
c.segment = seg
d.segment = seg
evt.segment = seg
train.segment = seg
train2.segment = seg
epc.segment = seg
epc2.segment = seg
# write to file
test_file_name = "test_round_trip.nwb"
iow = NWBIO(filename=test_file_name, mode='w')
iow.write_all_blocks(original_blocks)
ior = NWBIO(filename=test_file_name, mode='r')
retrieved_blocks = ior.read_all_blocks()
self.assertEqual(len(retrieved_blocks), 3)
self.assertEqual(len(retrieved_blocks[2].segments), num_seg)
original_signal_22b = original_blocks[2].segments[2].analogsignals[1]
retrieved_signal_22b = retrieved_blocks[2].segments[2].analogsignals[1]
for attr_name in ("name", "units", "sampling_rate", "t_start"):
retrieved_attribute = getattr(retrieved_signal_22b, attr_name)
original_attribute = getattr(original_signal_22b, attr_name)
self.assertEqual(retrieved_attribute, original_attribute)
assert_array_equal(retrieved_signal_22b.magnitude,
original_signal_22b.magnitude)
original_issignal_22d = original_blocks[2].segments[
2].irregularlysampledsignals[0]
retrieved_issignal_22d = retrieved_blocks[2].segments[
2].irregularlysampledsignals[0]
for attr_name in ("name", "units", "t_start"):
retrieved_attribute = getattr(retrieved_issignal_22d, attr_name)
original_attribute = getattr(original_issignal_22d, attr_name)
self.assertEqual(retrieved_attribute, original_attribute)
assert_array_equal(
retrieved_issignal_22d.times.rescale('ms').magnitude,
original_issignal_22d.times.rescale('ms').magnitude)
assert_array_equal(retrieved_issignal_22d.magnitude,
original_issignal_22d.magnitude)
original_event_11 = original_blocks[1].segments[1].events[0]
retrieved_event_11 = retrieved_blocks[1].segments[1].events[0]
for attr_name in ("name", ):
retrieved_attribute = getattr(retrieved_event_11, attr_name)
original_attribute = getattr(original_event_11, attr_name)
self.assertEqual(retrieved_attribute, original_attribute)
assert_array_equal(
retrieved_event_11.rescale('ms').magnitude,
original_event_11.rescale('ms').magnitude)
assert_array_equal(retrieved_event_11.labels, original_event_11.labels)
original_spiketrain_131 = original_blocks[1].segments[1].spiketrains[1]
retrieved_spiketrain_131 = retrieved_blocks[1].segments[1].spiketrains[
1]
for attr_name in ("name", "t_start", "t_stop"):
retrieved_attribute = getattr(retrieved_spiketrain_131, attr_name)
original_attribute = getattr(original_spiketrain_131, attr_name)
self.assertEqual(retrieved_attribute, original_attribute)
assert_array_equal(
retrieved_spiketrain_131.times.rescale('ms').magnitude,
original_spiketrain_131.times.rescale('ms').magnitude)
original_epoch_11 = original_blocks[1].segments[1].epochs[0]
retrieved_epoch_11 = retrieved_blocks[1].segments[1].epochs[0]
for attr_name in ("name", ):
retrieved_attribute = getattr(retrieved_epoch_11, attr_name)
original_attribute = getattr(original_epoch_11, attr_name)
self.assertEqual(retrieved_attribute, original_attribute)
assert_array_equal(
retrieved_epoch_11.rescale('ms').magnitude,
original_epoch_11.rescale('ms').magnitude)
assert_allclose(
retrieved_epoch_11.durations.rescale('ms').magnitude,
original_epoch_11.durations.rescale('ms').magnitude)
assert_array_equal(retrieved_epoch_11.labels, original_epoch_11.labels)
os.remove(test_file_name)
def test__issue_285(self):
# Spiketrain
train = SpikeTrain([3, 4, 5] * pq.s, t_stop=10.0)
unit = Unit()
train.unit = unit
unit.spiketrains.append(train)
epoch = Epoch(np.array([0, 10, 20]),
np.array([2, 2, 2]),
np.array(["a", "b", "c"]),
units="ms")
blk = Block()
seg = Segment()
seg.spiketrains.append(train)
seg.epochs.append(epoch)
epoch.segment = seg
blk.segments.append(seg)
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.spiketrains[0].unit, Unit)
self.assertIsInstance(r_seg.epochs[0], Epoch)
os.remove('blk.pkl')
# Epoch
epoch = Epoch(times=np.arange(0, 30, 10) * pq.s,
durations=[10, 5, 7] * pq.ms,
labels=np.array(['btn0', 'btn1', 'btn2'], dtype='S'))
epoch.segment = Segment()
blk = Block()
seg = Segment()
seg.epochs.append(epoch)
blk.segments.append(seg)
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.epochs[0].segment, Segment)
os.remove('blk.pkl')
# Event
event = Event(np.arange(0, 30, 10) * pq.s,
labels=np.array(['trig0', 'trig1', 'trig2'], dtype='S'))
event.segment = Segment()
blk = Block()
seg = Segment()
seg.events.append(event)
blk.segments.append(seg)
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.events[0].segment, Segment)
os.remove('blk.pkl')
# IrregularlySampledSignal
signal = IrregularlySampledSignal(
[0.0, 1.23, 6.78], [1, 2, 3], units='mV', time_units='ms')
signal.segment = Segment()
blk = Block()
seg = Segment()
seg.irregularlysampledsignals.append(signal)
blk.segments.append(seg)
blk.segments[0].block = blk
reader = PickleIO(filename="blk.pkl")
reader.write(blk)
reader = PickleIO(filename="blk.pkl")
r_blk = reader.read_block()
r_seg = r_blk.segments[0]
self.assertIsInstance(r_seg.irregularlysampledsignals[0].segment, Segment)
os.remove('blk.pkl')
