def test__construct_subsegment_by_unit(self):
nb_seg = 3
nb_unit = 7
unit_with_sig = [0, 2, 5]
signal_types = ['Vm', 'Conductances']
sig_len = 100
#recordingchannelgroups
rcgs = [ RecordingChannelGroup(name = 'Vm', channel_indexes = unit_with_sig),
RecordingChannelGroup(name = 'Conductance', channel_indexes = unit_with_sig), ]
# Unit
all_unit = [ ]
for u in range(nb_unit):
un = Unit(name = 'Unit #%d' % u, channel_indexes = [u])
all_unit.append(un)
bl = Block()
for s in range(nb_seg):
seg = Segment(name = 'Simulation %s' % s)
for j in range(nb_unit):
st = SpikeTrain([1, 2, 3], units = 'ms', t_start = 0., t_stop = 10)
st.unit = all_unit[j]
for t in signal_types:
anasigarr = AnalogSignalArray( np.zeros((sig_len, len(unit_with_sig)) ), units = 'nA',
sampling_rate = 1000.*pq.Hz, channel_indexes = unit_with_sig )
seg.analogsignalarrays.append(anasigarr)
# what you want
subseg = seg.construct_subsegment_by_unit(all_unit[:4])
def test_time_slice_None(self):
time_slices = [(None, 5.0 * pq.s), (5.0 * pq.s, None), (None, None)]
anasig = AnalogSignal(np.arange(50.0) * pq.mV,
sampling_rate=1.0 * pq.Hz)
seg = Segment()
seg.analogsignals = [anasig]
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test without resetting the time
for t_start, t_stop in time_slices:
sliced = seg.time_slice(t_start, t_stop)
assert_neo_object_is_compliant(sliced)
self.assertEqual(len(sliced.analogsignals), 1)
exp_t_start, exp_t_stop = t_start, t_stop
if exp_t_start is None:
exp_t_start = seg.t_start
if exp_t_stop is None:
exp_t_stop = seg.t_stop
self.assertEqual(exp_t_start, sliced.t_start)
self.assertEqual(exp_t_stop, sliced.t_stop)
def __init__(self, segment, identifier):
"""
"""
self.init = True
Segment.__init__(self, name=segment.name,
description=segment.description,
file_origin=segment.file_origin,
file_datetime=segment.file_datetime,
rec_datetime=segment.rec_datetime,
index=segment.index)
self.annotations = segment.annotations
self.identifier = identifier
# indicates whether the segment has been fully loaded
self.full = False
def test__construct_subsegment_by_unit(self):
nb_seg = 3
nb_unit = 7
unit_with_sig = np.array([0, 2, 5])
signal_types = ['Vm', 'Conductances']
sig_len = 100
# channelindexes
chxs = [ChannelIndex(name='Vm',
index=unit_with_sig),
ChannelIndex(name='Conductance',
index=unit_with_sig)]
# Unit
all_unit = []
for u in range(nb_unit):
un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u]))
assert_neo_object_is_compliant(un)
all_unit.append(un)
blk = Block()
blk.channel_indexes = chxs
for s in range(nb_seg):
seg = Segment(name='Simulation %s' % s)
for j in range(nb_unit):
st = SpikeTrain([1, 2], units='ms',
t_start=0., t_stop=10)
st.unit = all_unit[j]
for t in signal_types:
anasigarr = AnalogSignal(np.zeros((sig_len,
len(unit_with_sig))),
units='nA',
sampling_rate=1000.*pq.Hz,
channel_indexes=unit_with_sig)
seg.analogsignals.append(anasigarr)
blk.create_many_to_one_relationship()
for unit in all_unit:
assert_neo_object_is_compliant(unit)
for chx in chxs:
assert_neo_object_is_compliant(chx)
assert_neo_object_is_compliant(blk)
# what you want
newseg = seg.construct_subsegment_by_unit(all_unit[:4])
assert_neo_object_is_compliant(newseg)
def test__construct_subsegment_by_unit(self):
nb_seg = 3
nb_unit = 7
unit_with_sig = np.array([0, 2, 5])
signal_types = ['Vm', 'Conductances']
sig_len = 100
# channelindexes
chxs = [ChannelIndex(name='Vm',
index=unit_with_sig),
ChannelIndex(name='Conductance',
index=unit_with_sig)]
# Unit
all_unit = []
for u in range(nb_unit):
un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u]))
assert_neo_object_is_compliant(un)
all_unit.append(un)
blk = Block()
blk.channel_indexes = chxs
for s in range(nb_seg):
seg = Segment(name='Simulation %s' % s)
for j in range(nb_unit):
st = SpikeTrain([1, 2], units='ms',
t_start=0., t_stop=10)
st.unit = all_unit[j]
for t in signal_types:
anasigarr = AnalogSignal(np.zeros((sig_len,
len(unit_with_sig))),
units='nA',
sampling_rate=1000. * pq.Hz,
channel_indexes=unit_with_sig)
seg.analogsignals.append(anasigarr)
blk.create_many_to_one_relationship()
for unit in all_unit:
assert_neo_object_is_compliant(unit)
for chx in chxs:
assert_neo_object_is_compliant(chx)
assert_neo_object_is_compliant(blk)
# what you want
newseg = seg.construct_subsegment_by_unit(all_unit[:4])
assert_neo_object_is_compliant(newseg)
def setup_segments(self):
params = {'testarg2': 'yes', 'testarg3': True}
self.segment1 = Segment(name='test', description='tester 1',
file_origin='test.file',
testarg1=1, **params)
self.segment2 = Segment(name='test', description='tester 2',
file_origin='test.file',
testarg1=1, **params)
self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3])
self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3])
self.segment1.analogsignals = self.sig1
self.segment2.analogsignals = self.sig2
self.segment1.analogsignalarrays = self.sigarr1
self.segment2.analogsignalarrays = self.sigarr2
self.segment1.epochs = self.epoch1
self.segment2.epochs = self.epoch2
self.segment1.epocharrays = self.epocharr1
self.segment2.epocharrays = self.epocharr2
self.segment1.events = self.event1
self.segment2.events = self.event2
self.segment1.eventarrays = self.eventarr1
self.segment2.eventarrays = self.eventarr2
self.segment1.irregularlysampledsignals = self.irsig1
self.segment2.irregularlysampledsignals = self.irsig2
self.segment1.spikes = self.spike1
self.segment2.spikes = self.spike2
self.segment1.spiketrains = self.train1
self.segment2.spiketrains = self.train2
create_many_to_one_relationship(self.segment1)
create_many_to_one_relationship(self.segment2)
def setup_segments(self):
params = {'testarg2': 'yes', 'testarg3': True}
self.segment1 = Segment(name='test', description='tester 1',
file_origin='test.file',
testarg1=1, **params)
self.segment2 = Segment(name='test', description='tester 2',
file_origin='test.file',
testarg1=1, **params)
self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3])
self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3])
self.segment1.analogsignals = self.sig1
self.segment2.analogsignals = self.sig2
self.segment1.analogsignalarrays = self.sigarr1
self.segment2.analogsignalarrays = self.sigarr2
self.segment1.epochs = self.epoch1
self.segment2.epochs = self.epoch2
self.segment1.epocharrays = self.epocharr1
self.segment2.epocharrays = self.epocharr2
self.segment1.events = self.event1
self.segment2.events = self.event2
self.segment1.eventarrays = self.eventarr1
self.segment2.eventarrays = self.eventarr2
self.segment1.irregularlysampledsignals = self.irsig1
self.segment2.irregularlysampledsignals = self.irsig2
self.segment1.spikes = self.spike1
self.segment2.spikes = self.spike2
self.segment1.spiketrains = self.train1
self.segment2.spiketrains = self.train2
self.segment1.create_many_to_one_relationship()
self.segment2.create_many_to_one_relationship()
def setUp(self):
test_data = np.random.rand(100, 8) * pq.mV
channel_names = np.array(["a", "b", "c", "d", "e", "f", "g", "h"])
self.test_signal = AnalogSignal(test_data,
sampling_period=0.1 * pq.ms,
name="test signal",
description="this is a test signal",
array_annotations={"channel_names": channel_names},
attUQoLtUaE=42)
self.test_view = ChannelView(self.test_signal, [1, 2, 5, 7],
name="view of test signal",
description="this is a view of a test signal",
array_annotations={"something": np.array(["A", "B", "C", "D"])},
sLaTfat="fish")
self.test_spiketrains = [SpikeTrain(np.arange(100.0), units="ms", t_stop=200),
SpikeTrain(np.arange(0.5, 100.5), units="ms", t_stop=200)]
self.test_segment = Segment()
self.test_segment.analogsignals.append(self.test_signal)
self.test_segment.spiketrains.extend(self.test_spiketrains)
def test_init(self):
seg = Segment(name='a segment', index=3)
assert_neo_object_is_compliant(seg)
self.assertEqual(seg.name, 'a segment')
self.assertEqual(seg.file_origin, None)
self.assertEqual(seg.index, 3)
def setUp(self):
unitname11 = 'unit 1 1'
unitname12 = 'unit 1 2'
unitname21 = 'unit 2 1'
unitname22 = 'unit 2 2'
channame11 = 'chan 1 1'
channame12 = 'chan 1 2'
channame21 = 'chan 2 1'
channame22 = 'chan 2 2'
segname11 = 'seg 1 1'
segname12 = 'seg 1 2'
segname21 = 'seg 2 1'
segname22 = 'seg 2 2'
self.rcgname1 = 'rcg 1'
self.rcgname2 = 'rcg 2'
self.rcgnames = [self.rcgname1, self.rcgname2]
self.unitnames1 = [unitname11, unitname12]
self.unitnames2 = [unitname21, unitname22, unitname11]
self.unitnames = [unitname11, unitname12, unitname21, unitname22]
self.channames1 = [channame11, channame12]
self.channames2 = [channame21, channame22, channame11]
self.channames = [channame11, channame12, channame21, channame22]
self.segnames1 = [segname11, segname12]
self.segnames2 = [segname21, segname22, segname11]
self.segnames = [segname11, segname12, segname21, segname22]
unit11 = Unit(name=unitname11)
unit12 = Unit(name=unitname12)
unit21 = Unit(name=unitname21)
unit22 = Unit(name=unitname22)
unit23 = unit11
chan11 = RecordingChannel(name=channame11)
chan12 = RecordingChannel(name=channame12)
chan21 = RecordingChannel(name=channame21)
chan22 = RecordingChannel(name=channame22)
chan23 = chan11
seg11 = Segment(name=segname11)
seg12 = Segment(name=segname12)
seg21 = Segment(name=segname21)
seg22 = Segment(name=segname22)
seg23 = seg11
self.units1 = [unit11, unit12]
self.units2 = [unit21, unit22, unit23]
self.units = [unit11, unit12, unit21, unit22]
self.chan1 = [chan11, chan12]
self.chan2 = [chan21, chan22, chan23]
self.chan = [chan11, chan12, chan21, chan22]
self.seg1 = [seg11, seg12]
self.seg2 = [seg21, seg22, seg23]
self.seg = [seg11, seg12, seg21, seg22]
self.rcg1 = RecordingChannelGroup(name=self.rcgname1)
self.rcg2 = RecordingChannelGroup(name=self.rcgname2)
self.rcg = [self.rcg1, self.rcg2]
self.rcg1.units = self.units1
self.rcg2.units = self.units2
self.rcg1.recordingchannels = self.chan1
self.rcg2.recordingchannels = self.chan2
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 test_times(self):
for seg in [self.seg1, self.seg2]:
# calculate target values for t_start and t_stop
t_starts, t_stops = [], []
for children in [
seg.analogsignals, seg.epochs, seg.events,
seg.irregularlysampledsignals, seg.spiketrains
]:
for child in children:
if hasattr(child, 't_start'):
t_starts.append(child.t_start)
if hasattr(child, 't_stop'):
t_stops.append(child.t_stop)
if hasattr(child, 'time'):
t_starts.append(child.time)
t_stops.append(child.time)
if hasattr(child, 'times'):
t_starts.append(child.times[0])
t_stops.append(child.times[-1])
targ_t_start = min(t_starts)
targ_t_stop = max(t_stops)
self.assertEqual(seg.t_start, targ_t_start)
self.assertEqual(seg.t_stop, targ_t_stop)
# Testing times with ProxyObjects
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)
seg.epochs.append(proxy_epoch)
t_starts, t_stops = [], []
for children in [
seg.analogsignals, seg.epochs, seg.events,
seg.irregularlysampledsignals, seg.spiketrains
]:
for child in children:
if hasattr(child, 't_start'):
t_starts.append(child.t_start)
if hasattr(child, 't_stop'):
t_stops.append(child.t_stop)
if hasattr(child, 'time'):
t_starts.append(child.time)
t_stops.append(child.time)
if hasattr(child, 'times'):
t_starts.append(child.times[0])
t_stops.append(child.times[-1])
targ_t_start = min(t_starts)
targ_t_stop = max(t_stops)
self.assertEqual(seg.t_start, targ_t_start)
self.assertEqual(seg.t_stop, targ_t_stop)
def test_init(self):
seg = Segment(name='a segment', index=3)
self.assertEqual(seg.name, 'a segment')
self.assertEqual(seg.file_origin, None)
self.assertEqual(seg.index, 3)
def merge_datastores(
datastores,
root_directory,
merge_recordings=True,
merge_analysis=True,
merge_stimuli=True,
replace=False,
):
"""
This function takes a tuple of datastore in input and merge them into one single datastore which will be saved in root_directory.
The type of data that should be merged can be controlled through the merge_recordings, merge_analysis and merge_stimuli booleans
It returns this datastore as a Datastore object.
"""
merged_datastore = PickledDataStore(
load=False,
parameters=ParameterSet({
"root_directory": root_directory,
"store_stimuli": merge_stimuli
}),
replace=replace,
)
j = 0
# Here we check if sheets and neurons are the same in all datastores
assert compare_sheets_datastores(
datastores), "All datastores should contain the same sheets"
assert compare_neurons_ids_datastores(
datastores), "Neurons in the datastores should have the same ids"
assert compare_neurons_position_datastores(
datastores), "Neurons in the datastores should have the same position"
assert compare_neurons_annotations_datastores(
datastores
), "Neurons in the datastores should have the same annotations"
if not os.path.isdir(root_directory):
os.makedirs(root_directory)
# Change the block annotations so that it gets the merged version of the experiment parameters
merged_datastore.block.annotations = datastores[0].block.annotations
merged_datastore.block.annotations[
"experiment_parameters"] = merge_experiment_parameters_datastores(
datastores)
j = 0
for datastore in datastores:
# Merge the recording of all the datastores if this flag is set to true
if merge_recordings:
segments = datastore.get_segments()
segments += datastore.get_segments(null=True)
for seg in segments:
for s in merged_datastore.get_segments():
if seg.annotations == s.annotations and seg.null == s.null:
print(
"Warning: A segment with the same parametrization was already added in the datastore.: %s"
% (seg.annotations))
raise ValueError(
"A segment with the same parametrization was already added in the datastore already added in the datastore. Currently uniqueness is required. User should check what caused this and modify his simulations to avoid this!: %s \n %s"
% (str(seg.annotations), str(s.annotations)))
# Load the full segment and adds it to the merged datastore
if not seg.full:
seg.load_full()
merged_datastore.block.segments.append(
PickledDataStoreNeoWrapper(seg,
"Segment" + str(j),
root_directory,
null=seg.null))
merged_datastore.stimulus_dict[
seg.annotations["stimulus"]] = True
# Create a new pickle file for this mozaik segment and store a corresponding neo segment there
f = open(root_directory + "/" + "Segment" + str(j) + ".pickle",
"wb")
s = Segment(description=seg.description,
file_origin=seg.file_origin,
file_datetime=seg.file_datetime,
rec_datetime=seg.rec_datetime,
index=seg.index,
**seg.annotations)
s.spiketrains = seg.spiketrains
s.analogsignals = seg.analogsignals
pickle.dump(s, f)
# Release each segment once it has been added to the merged datastore to save memory
seg.release()
j = j + 1
# Merge the analysis of all the datastores if this flag is set to true
if merge_analysis:
adss = datastore.get_analysis_result()
for ads in adss:
merged_datastore.add_analysis_result(ads)
# Merge the stimuli all the datastores if this flag is set to true
if merge_stimuli:
for key, value in datastore.sensory_stimulus.items():
merged_datastore.sensory_stimulus[key] = value
return merged_datastore
class TestSegment(unittest.TestCase):
def setUp(self):
self.setup_analogsignals()
self.setup_analogsignalarrays()
self.setup_epochs()
self.setup_epocharrays()
self.setup_events()
self.setup_eventarrays()
self.setup_irregularlysampledsignals()
self.setup_spikes()
self.setup_spiketrains()
self.setup_units()
self.setup_segments()
def setup_segments(self):
params = {'testarg2': 'yes', 'testarg3': True}
self.segment1 = Segment(name='test', description='tester 1',
file_origin='test.file',
testarg1=1, **params)
self.segment2 = Segment(name='test', description='tester 2',
file_origin='test.file',
testarg1=1, **params)
self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3])
self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3])
self.segment1.analogsignals = self.sig1
self.segment2.analogsignals = self.sig2
self.segment1.analogsignalarrays = self.sigarr1
self.segment2.analogsignalarrays = self.sigarr2
self.segment1.epochs = self.epoch1
self.segment2.epochs = self.epoch2
self.segment1.epocharrays = self.epocharr1
self.segment2.epocharrays = self.epocharr2
self.segment1.events = self.event1
self.segment2.events = self.event2
self.segment1.eventarrays = self.eventarr1
self.segment2.eventarrays = self.eventarr2
self.segment1.irregularlysampledsignals = self.irsig1
self.segment2.irregularlysampledsignals = self.irsig2
self.segment1.spikes = self.spike1
self.segment2.spikes = self.spike2
self.segment1.spiketrains = self.train1
self.segment2.spiketrains = self.train2
create_many_to_one_relationship(self.segment1)
create_many_to_one_relationship(self.segment2)
def setup_units(self):
params = {'testarg2': 'yes', 'testarg3': True}
self.unit1 = Unit(name='test', description='tester 1',
file_origin='test.file',
channel_indexes=np.array([1]),
testarg1=1, **params)
self.unit2 = Unit(name='test', description='tester 2',
file_origin='test.file',
channel_indexes=np.array([2]),
testarg1=1, **params)
self.unit1.annotate(testarg1=1.1, testarg0=[1, 2, 3])
self.unit2.annotate(testarg11=1.1, testarg10=[1, 2, 3])
self.unit1train = [self.train1[0], self.train2[1]]
self.unit2train = [self.train1[1], self.train2[0]]
self.unit1.spiketrains = self.unit1train
self.unit2.spiketrains = self.unit2train
self.unit1spike = [self.spike1[0], self.spike2[1]]
self.unit2spike = [self.spike1[1], self.spike2[0]]
self.unit1.spikes = self.unit1spike
self.unit2.spikes = self.unit2spike
create_many_to_one_relationship(self.unit1)
create_many_to_one_relationship(self.unit2)
def setup_analogsignals(self):
signame11 = 'analogsignal 1 1'
signame12 = 'analogsignal 1 2'
signame21 = 'analogsignal 2 1'
signame22 = 'analogsignal 2 2'
sigdata11 = np.arange(0, 10) * pq.mV
sigdata12 = np.arange(10, 20) * pq.mV
sigdata21 = np.arange(20, 30) * pq.V
sigdata22 = np.arange(30, 40) * pq.V
self.signames1 = [signame11, signame12]
self.signames2 = [signame21, signame22]
self.signames = [signame11, signame12, signame21, signame22]
sig11 = AnalogSignal(sigdata11, name=signame11,
channel_index=1, sampling_rate=1*pq.Hz)
sig12 = AnalogSignal(sigdata12, name=signame12,
channel_index=2, sampling_rate=1*pq.Hz)
sig21 = AnalogSignal(sigdata21, name=signame21,
channel_index=1, sampling_rate=1*pq.Hz)
sig22 = AnalogSignal(sigdata22, name=signame22,
channel_index=2, sampling_rate=1*pq.Hz)
self.sig1 = [sig11, sig12]
self.sig2 = [sig21, sig22]
self.sig = [sig11, sig12, sig21, sig22]
self.chan1sig = [self.sig1[0], self.sig2[0]]
self.chan2sig = [self.sig1[1], self.sig2[1]]
def setup_analogsignalarrays(self):
sigarrname11 = 'analogsignalarray 1 1'
sigarrname12 = 'analogsignalarray 1 2'
sigarrname21 = 'analogsignalarray 2 1'
sigarrname22 = 'analogsignalarray 2 2'
sigarrdata11 = np.arange(0, 10).reshape(5, 2) * pq.mV
sigarrdata12 = np.arange(10, 20).reshape(5, 2) * pq.mV
sigarrdata21 = np.arange(20, 30).reshape(5, 2) * pq.V
sigarrdata22 = np.arange(30, 40).reshape(5, 2) * pq.V
sigarrdata112 = np.hstack([sigarrdata11, sigarrdata11]) * pq.mV
self.sigarrnames1 = [sigarrname11, sigarrname12]
self.sigarrnames2 = [sigarrname21, sigarrname22, sigarrname11]
self.sigarrnames = [sigarrname11, sigarrname12,
sigarrname21, sigarrname22]
sigarr11 = AnalogSignalArray(sigarrdata11, name=sigarrname11,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
sigarr12 = AnalogSignalArray(sigarrdata12, name=sigarrname12,
sampling_rate=1*pq.Hz,
channel_index=np.array([2, 1]))
sigarr21 = AnalogSignalArray(sigarrdata21, name=sigarrname21,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
sigarr22 = AnalogSignalArray(sigarrdata22, name=sigarrname22,
sampling_rate=1*pq.Hz,
channel_index=np.array([2, 1]))
sigarr23 = AnalogSignalArray(sigarrdata11, name=sigarrname11,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
sigarr112 = AnalogSignalArray(sigarrdata112, name=sigarrname11,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
self.sigarr1 = [sigarr11, sigarr12]
self.sigarr2 = [sigarr21, sigarr22, sigarr23]
self.sigarr = [sigarr112, sigarr12, sigarr21, sigarr22]
self.chan1sigarr1 = [sigarr11[:, 0:1], sigarr12[:, 1:2]]
self.chan2sigarr1 = [sigarr11[:, 1:2], sigarr12[:, 0:1]]
self.chan1sigarr2 = [sigarr21[:, 0:1], sigarr22[:, 1:2],
sigarr23[:, 0:1]]
self.chan2sigarr2 = [sigarr21[:, 1:2], sigarr22[:, 0:1],
sigarr23[:, 0:1]]
def setup_epochs(self):
epochname11 = 'epoch 1 1'
epochname12 = 'epoch 1 2'
epochname21 = 'epoch 2 1'
epochname22 = 'epoch 2 2'
epochtime11 = 10 * pq.ms
epochtime12 = 20 * pq.ms
epochtime21 = 30 * pq.s
epochtime22 = 40 * pq.s
epochdur11 = 11 * pq.s
epochdur12 = 21 * pq.s
epochdur21 = 31 * pq.ms
epochdur22 = 41 * pq.ms
self.epochnames1 = [epochname11, epochname12]
self.epochnames2 = [epochname21, epochname22]
self.epochnames = [epochname11, epochname12, epochname21, epochname22]
epoch11 = Epoch(epochtime11, epochdur11,
label=epochname11, name=epochname11, channel_index=1,
testattr=True)
epoch12 = Epoch(epochtime12, epochdur12,
label=epochname12, name=epochname12, channel_index=2,
testattr=False)
epoch21 = Epoch(epochtime21, epochdur21,
label=epochname21, name=epochname21, channel_index=1)
epoch22 = Epoch(epochtime22, epochdur22,
label=epochname22, name=epochname22, channel_index=2)
self.epoch1 = [epoch11, epoch12]
self.epoch2 = [epoch21, epoch22]
self.epoch = [epoch11, epoch12, epoch21, epoch22]
def setup_epocharrays(self):
epocharrname11 = 'epocharr 1 1'
epocharrname12 = 'epocharr 1 2'
epocharrname21 = 'epocharr 2 1'
epocharrname22 = 'epocharr 2 2'
epocharrtime11 = np.arange(0, 10) * pq.ms
epocharrtime12 = np.arange(10, 20) * pq.ms
epocharrtime21 = np.arange(20, 30) * pq.s
epocharrtime22 = np.arange(30, 40) * pq.s
epocharrdur11 = np.arange(1, 11) * pq.s
epocharrdur12 = np.arange(11, 21) * pq.s
epocharrdur21 = np.arange(21, 31) * pq.ms
epocharrdur22 = np.arange(31, 41) * pq.ms
self.epocharrnames1 = [epocharrname11, epocharrname12]
self.epocharrnames2 = [epocharrname21, epocharrname22]
self.epocharrnames = [epocharrname11,
epocharrname12, epocharrname21, epocharrname22]
epocharr11 = EpochArray(epocharrtime11, epocharrdur11,
label=epocharrname11, name=epocharrname11)
epocharr12 = EpochArray(epocharrtime12, epocharrdur12,
label=epocharrname12, name=epocharrname12)
epocharr21 = EpochArray(epocharrtime21, epocharrdur21,
label=epocharrname21, name=epocharrname21)
epocharr22 = EpochArray(epocharrtime22, epocharrdur22,
label=epocharrname22, name=epocharrname22)
self.epocharr1 = [epocharr11, epocharr12]
self.epocharr2 = [epocharr21, epocharr22]
self.epocharr = [epocharr11, epocharr12, epocharr21, epocharr22]
def setup_events(self):
eventname11 = 'event 1 1'
eventname12 = 'event 1 2'
eventname21 = 'event 2 1'
eventname22 = 'event 2 2'
eventtime11 = 10 * pq.ms
eventtime12 = 20 * pq.ms
eventtime21 = 30 * pq.s
eventtime22 = 40 * pq.s
self.eventnames1 = [eventname11, eventname12]
self.eventnames2 = [eventname21, eventname22]
self.eventnames = [eventname11, eventname12, eventname21, eventname22]
params1 = {'testattr': True}
params2 = {'testattr': 5}
event11 = Event(eventtime11, label=eventname11, name=eventname11,
**params1)
event12 = Event(eventtime12, label=eventname12, name=eventname12,
**params2)
event21 = Event(eventtime21, label=eventname21, name=eventname21)
event22 = Event(eventtime22, label=eventname22, name=eventname22)
self.event1 = [event11, event12]
self.event2 = [event21, event22]
self.event = [event11, event12, event21, event22]
def setup_eventarrays(self):
eventarrname11 = 'eventarr 1 1'
eventarrname12 = 'eventarr 1 2'
eventarrname21 = 'eventarr 2 1'
eventarrname22 = 'eventarr 2 2'
eventarrtime11 = np.arange(0, 10) * pq.ms
eventarrtime12 = np.arange(10, 20) * pq.ms
eventarrtime21 = np.arange(20, 30) * pq.s
eventarrtime22 = np.arange(30, 40) * pq.s
self.eventarrnames1 = [eventarrname11, eventarrname12]
self.eventarrnames2 = [eventarrname21, eventarrname22]
self.eventarrnames = [eventarrname11,
eventarrname12, eventarrname21, eventarrname22]
eventarr11 = EventArray(eventarrtime11,
label=eventarrname11, name=eventarrname11)
eventarr12 = EventArray(eventarrtime12,
label=eventarrname12, name=eventarrname12)
eventarr21 = EventArray(eventarrtime21,
label=eventarrname21, name=eventarrname21)
eventarr22 = EventArray(eventarrtime22,
label=eventarrname22, name=eventarrname22)
self.eventarr1 = [eventarr11, eventarr12]
self.eventarr2 = [eventarr21, eventarr22]
self.eventarr = [eventarr11, eventarr12, eventarr21, eventarr22]
def setup_irregularlysampledsignals(self):
irsigname11 = 'irregularsignal 1 1'
irsigname12 = 'irregularsignal 1 2'
irsigname21 = 'irregularsignal 2 1'
irsigname22 = 'irregularsignal 2 2'
irsigdata11 = np.arange(0, 10) * pq.mA
irsigdata12 = np.arange(10, 20) * pq.mA
irsigdata21 = np.arange(20, 30) * pq.A
irsigdata22 = np.arange(30, 40) * pq.A
irsigtimes11 = np.arange(0, 10) * pq.ms
irsigtimes12 = np.arange(10, 20) * pq.ms
irsigtimes21 = np.arange(20, 30) * pq.s
irsigtimes22 = np.arange(30, 40) * pq.s
self.irsignames1 = [irsigname11, irsigname12]
self.irsignames2 = [irsigname21, irsigname22]
self.irsignames = [irsigname11, irsigname12, irsigname21, irsigname22]
irsig11 = IrregularlySampledSignal(irsigtimes11, irsigdata11,
name=irsigname11)
irsig12 = IrregularlySampledSignal(irsigtimes12, irsigdata12,
name=irsigname12)
irsig21 = IrregularlySampledSignal(irsigtimes21, irsigdata21,
name=irsigname21)
irsig22 = IrregularlySampledSignal(irsigtimes22, irsigdata22,
name=irsigname22)
self.irsig1 = [irsig11, irsig12]
self.irsig2 = [irsig21, irsig22]
self.irsig = [irsig11, irsig12, irsig21, irsig22]
def setup_spikes(self):
spikename11 = 'spike 1 1'
spikename12 = 'spike 1 2'
spikename21 = 'spike 2 1'
spikename22 = 'spike 2 2'
spikedata11 = 10 * pq.ms
spikedata12 = 20 * pq.ms
spikedata21 = 30 * pq.s
spikedata22 = 40 * pq.s
self.spikenames1 = [spikename11, spikename12]
self.spikenames2 = [spikename21, spikename22]
self.spikenames = [spikename11, spikename12, spikename21, spikename22]
spike11 = Spike(spikedata11, t_stop=100*pq.s, name=spikename11)
spike12 = Spike(spikedata12, t_stop=100*pq.s, name=spikename12)
spike21 = Spike(spikedata21, t_stop=100*pq.s, name=spikename21)
spike22 = Spike(spikedata22, t_stop=100*pq.s, name=spikename22)
self.spike1 = [spike11, spike12]
self.spike2 = [spike21, spike22]
self.spike = [spike11, spike12, spike21, spike22]
def setup_spiketrains(self):
trainname11 = 'spiketrain 1 1'
trainname12 = 'spiketrain 1 2'
trainname21 = 'spiketrain 2 1'
trainname22 = 'spiketrain 2 2'
traindata11 = np.arange(0, 10) * pq.ms
traindata12 = np.arange(10, 20) * pq.ms
traindata21 = np.arange(20, 30) * pq.s
traindata22 = np.arange(30, 40) * pq.s
self.trainnames1 = [trainname11, trainname12]
self.trainnames2 = [trainname21, trainname22]
self.trainnames = [trainname11, trainname12, trainname21, trainname22]
train11 = SpikeTrain(traindata11, t_stop=100*pq.s, name=trainname11)
train12 = SpikeTrain(traindata12, t_stop=100*pq.s, name=trainname12)
train21 = SpikeTrain(traindata21, t_stop=100*pq.s, name=trainname21)
train22 = SpikeTrain(traindata22, t_stop=100*pq.s, name=trainname22)
self.train1 = [train11, train12]
self.train2 = [train21, train22]
self.train = [train11, train12, train21, train22]
def test_init(self):
seg = Segment(name='a segment', index=3)
assert_neo_object_is_compliant(seg)
self.assertEqual(seg.name, 'a segment')
self.assertEqual(seg.file_origin, None)
self.assertEqual(seg.index, 3)
def test__construct_subsegment_by_unit(self):
nb_seg = 3
nb_unit = 7
unit_with_sig = np.array([0, 2, 5])
signal_types = ['Vm', 'Conductances']
sig_len = 100
#recordingchannelgroups
rcgs = [RecordingChannelGroup(name='Vm',
channel_indexes=unit_with_sig),
RecordingChannelGroup(name='Conductance',
channel_indexes=unit_with_sig)]
# Unit
all_unit = []
for u in range(nb_unit):
un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u]))
assert_neo_object_is_compliant(un)
all_unit.append(un)
blk = Block()
blk.recordingchannelgroups = rcgs
for s in range(nb_seg):
seg = Segment(name='Simulation %s' % s)
for j in range(nb_unit):
st = SpikeTrain([1, 2, 3], units='ms',
t_start=0., t_stop=10)
st.unit = all_unit[j]
for t in signal_types:
anasigarr = AnalogSignalArray(np.zeros((sig_len,
len(unit_with_sig))),
units='nA',
sampling_rate=1000.*pq.Hz,
channel_indexes=unit_with_sig)
seg.analogsignalarrays.append(anasigarr)
create_many_to_one_relationship(blk)
for unit in all_unit:
assert_neo_object_is_compliant(unit)
for rcg in rcgs:
assert_neo_object_is_compliant(rcg)
assert_neo_object_is_compliant(blk)
# what you want
newseg = seg.construct_subsegment_by_unit(all_unit[:4])
assert_neo_object_is_compliant(newseg)
def test_segment_creation(self):
assert_neo_object_is_compliant(self.segment1)
assert_neo_object_is_compliant(self.segment2)
assert_neo_object_is_compliant(self.unit1)
assert_neo_object_is_compliant(self.unit2)
self.assertEqual(self.segment1.name, 'test')
self.assertEqual(self.segment2.name, 'test')
self.assertEqual(self.segment1.description, 'tester 1')
self.assertEqual(self.segment2.description, 'tester 2')
self.assertEqual(self.segment1.file_origin, 'test.file')
self.assertEqual(self.segment2.file_origin, 'test.file')
self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3])
self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3])
self.assertEqual(self.segment1.annotations['testarg1'], 1.1)
self.assertEqual(self.segment2.annotations['testarg1'], 1)
self.assertEqual(self.segment2.annotations['testarg11'], 1.1)
self.assertEqual(self.segment1.annotations['testarg2'], 'yes')
self.assertEqual(self.segment2.annotations['testarg2'], 'yes')
self.assertTrue(self.segment1.annotations['testarg3'])
self.assertTrue(self.segment2.annotations['testarg3'])
self.assertTrue(hasattr(self.segment1, 'analogsignals'))
self.assertTrue(hasattr(self.segment2, 'analogsignals'))
self.assertEqual(len(self.segment1.analogsignals), 2)
self.assertEqual(len(self.segment2.analogsignals), 2)
for res, targ in zip(self.segment1.analogsignals, self.sig1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignals, self.sig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'analogsignalarrays'))
self.assertTrue(hasattr(self.segment2, 'analogsignalarrays'))
self.assertEqual(len(self.segment1.analogsignalarrays), 2)
self.assertEqual(len(self.segment2.analogsignalarrays), 3)
for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epochs'))
self.assertTrue(hasattr(self.segment2, 'epochs'))
self.assertEqual(len(self.segment1.epochs), 2)
self.assertEqual(len(self.segment2.epochs), 2)
for res, targ in zip(self.segment1.epochs, self.epoch1):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epochs, self.epoch2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epocharrays'))
self.assertTrue(hasattr(self.segment2, 'epocharrays'))
self.assertEqual(len(self.segment1.epocharrays), 2)
self.assertEqual(len(self.segment2.epocharrays), 2)
for res, targ in zip(self.segment1.epocharrays, self.epocharr1):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epocharrays, self.epocharr2):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'events'))
self.assertTrue(hasattr(self.segment2, 'events'))
self.assertEqual(len(self.segment1.events), 2)
self.assertEqual(len(self.segment2.events), 2)
for res, targ in zip(self.segment1.events, self.event1):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.events, self.event2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'eventarrays'))
self.assertTrue(hasattr(self.segment2, 'eventarrays'))
self.assertEqual(len(self.segment1.eventarrays), 2)
self.assertEqual(len(self.segment2.eventarrays), 2)
for res, targ in zip(self.segment1.eventarrays, self.eventarr1):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.eventarrays, self.eventarr2):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals'))
self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals'))
self.assertEqual(len(self.segment1.irregularlysampledsignals), 2)
self.assertEqual(len(self.segment2.irregularlysampledsignals), 2)
for res, targ in zip(self.segment1.irregularlysampledsignals,
self.irsig1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.irregularlysampledsignals,
self.irsig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spikes'))
self.assertTrue(hasattr(self.segment2, 'spikes'))
self.assertEqual(len(self.segment1.spikes), 2)
self.assertEqual(len(self.segment2.spikes), 2)
for res, targ in zip(self.segment1.spikes, self.spike1):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spikes, self.spike2):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spiketrains'))
self.assertTrue(hasattr(self.segment2, 'spiketrains'))
self.assertEqual(len(self.segment1.spiketrains), 2)
self.assertEqual(len(self.segment2.spiketrains), 2)
for res, targ in zip(self.segment1.spiketrains, self.train1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spiketrains, self.train2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_merge(self):
self.segment1.merge(self.segment2)
create_many_to_one_relationship(self.segment1, force=True)
assert_neo_object_is_compliant(self.segment1)
self.assertEqual(self.segment1.name, 'test')
self.assertEqual(self.segment2.name, 'test')
self.assertEqual(self.segment1.description, 'tester 1')
self.assertEqual(self.segment2.description, 'tester 2')
self.assertEqual(self.segment1.file_origin, 'test.file')
self.assertEqual(self.segment2.file_origin, 'test.file')
self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3])
self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3])
self.assertEqual(self.segment1.annotations['testarg1'], 1.1)
self.assertEqual(self.segment2.annotations['testarg1'], 1)
self.assertEqual(self.segment2.annotations['testarg11'], 1.1)
self.assertEqual(self.segment1.annotations['testarg2'], 'yes')
self.assertEqual(self.segment2.annotations['testarg2'], 'yes')
self.assertTrue(self.segment1.annotations['testarg3'])
self.assertTrue(self.segment2.annotations['testarg3'])
self.assertTrue(hasattr(self.segment1, 'analogsignals'))
self.assertTrue(hasattr(self.segment2, 'analogsignals'))
self.assertEqual(len(self.segment1.analogsignals), 4)
self.assertEqual(len(self.segment2.analogsignals), 2)
for res, targ in zip(self.segment1.analogsignals, self.sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignals, self.sig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'analogsignalarrays'))
self.assertTrue(hasattr(self.segment2, 'analogsignalarrays'))
self.assertEqual(len(self.segment1.analogsignalarrays), 4)
self.assertEqual(len(self.segment2.analogsignalarrays), 3)
for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epochs'))
self.assertTrue(hasattr(self.segment2, 'epochs'))
self.assertEqual(len(self.segment1.epochs), 4)
self.assertEqual(len(self.segment2.epochs), 2)
for res, targ in zip(self.segment1.epochs, self.epoch):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epochs, self.epoch2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epocharrays'))
self.assertTrue(hasattr(self.segment2, 'epocharrays'))
self.assertEqual(len(self.segment1.epocharrays), 4)
self.assertEqual(len(self.segment2.epocharrays), 2)
for res, targ in zip(self.segment1.epocharrays, self.epocharr):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epocharrays, self.epocharr2):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'events'))
self.assertTrue(hasattr(self.segment2, 'events'))
self.assertEqual(len(self.segment1.events), 4)
self.assertEqual(len(self.segment2.events), 2)
for res, targ in zip(self.segment1.events, self.event):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.events, self.event2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'eventarrays'))
self.assertTrue(hasattr(self.segment2, 'eventarrays'))
self.assertEqual(len(self.segment1.eventarrays), 4)
self.assertEqual(len(self.segment2.eventarrays), 2)
for res, targ in zip(self.segment1.eventarrays, self.eventarr):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.eventarrays, self.eventarr2):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals'))
self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals'))
self.assertEqual(len(self.segment1.irregularlysampledsignals), 4)
self.assertEqual(len(self.segment2.irregularlysampledsignals), 2)
for res, targ in zip(self.segment1.irregularlysampledsignals,
self.irsig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.irregularlysampledsignals,
self.irsig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spikes'))
self.assertTrue(hasattr(self.segment2, 'spikes'))
self.assertEqual(len(self.segment1.spikes), 4)
self.assertEqual(len(self.segment2.spikes), 2)
for res, targ in zip(self.segment1.spikes, self.spike):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spikes, self.spike2):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spiketrains'))
self.assertTrue(hasattr(self.segment2, 'spiketrains'))
self.assertEqual(len(self.segment1.spiketrains), 4)
self.assertEqual(len(self.segment2.spiketrains), 2)
for res, targ in zip(self.segment1.spiketrains, self.train):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spiketrains, self.train2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_all_data(self):
result1 = self.segment1.all_data
targs = (self.epoch1 + self.epocharr1 + self.event1 + self.eventarr1 +
self.sig1 + self.sigarr1 + self.irsig1 +
self.spike1 + self.train1)
for res, targ in zip(result1, targs):
if hasattr(res, 'ndim') and res.ndim:
assert_arrays_equal(res, targ)
else:
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_spikes_by_unit(self):
result1 = self.segment1.take_spikes_by_unit()
result21 = self.segment1.take_spikes_by_unit([self.unit1])
result22 = self.segment1.take_spikes_by_unit([self.unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.unit1spike):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.unit2spike):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_spiketrains_by_unit(self):
result1 = self.segment1.take_spiketrains_by_unit()
result21 = self.segment1.take_spiketrains_by_unit([self.unit1])
result22 = self.segment1.take_spiketrains_by_unit([self.unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.unit1train):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.unit2train):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_analogsignal_by_unit(self):
result1 = self.segment1.take_analogsignal_by_unit()
result21 = self.segment1.take_analogsignal_by_unit([self.unit1])
result22 = self.segment1.take_analogsignal_by_unit([self.unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_analogsignal_by_channelindex(self):
result1 = self.segment1.take_analogsignal_by_channelindex()
result21 = self.segment1.take_analogsignal_by_channelindex([1])
result22 = self.segment1.take_analogsignal_by_channelindex([2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_slice_of_analogsignalarray_by_unit(self):
segment = self.segment1
unit1 = self.unit1
unit2 = self.unit2
result1 = segment.take_slice_of_analogsignalarray_by_unit()
result21 = segment.take_slice_of_analogsignalarray_by_unit([unit1])
result22 = segment.take_slice_of_analogsignalarray_by_unit([unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_slice_of_analogsignalarray_by_channelindex(self):
segment = self.segment1
result1 = segment.take_slice_of_analogsignalarray_by_channelindex()
result21 = segment.take_slice_of_analogsignalarray_by_channelindex([1])
result22 = segment.take_slice_of_analogsignalarray_by_channelindex([2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_size(self):
result1 = self.segment1.size()
targ1 = {"epochs": 2, "events": 2, "analogsignals": 2,
"irregularlysampledsignals": 2, "spikes": 2,
"spiketrains": 2, "epocharrays": 2, "eventarrays": 2,
"analogsignalarrays": 2}
self.assertEqual(result1, targ1)
def test_segment_filter(self):
result1 = self.segment1.filter()
result2 = self.segment1.filter(name='analogsignal 1 1')
result3 = self.segment1.filter(testattr=True)
self.assertEqual(result1, [])
self.assertEqual(len(result2), 1)
assert_arrays_equal(result2[0], self.sig1[0])
self.assertEqual(len(result3), 2)
self.assertEqual(result3[0], self.epoch1[0])
self.assertEqual(result3[1], self.event1[0])
class TestSegment(unittest.TestCase):
def setUp(self):
self.setup_analogsignals()
self.setup_analogsignalarrays()
self.setup_epochs()
self.setup_epocharrays()
self.setup_events()
self.setup_eventarrays()
self.setup_irregularlysampledsignals()
self.setup_spikes()
self.setup_spiketrains()
self.setup_units()
self.setup_segments()
def setup_segments(self):
params = {'testarg2': 'yes', 'testarg3': True}
self.segment1 = Segment(name='test', description='tester 1',
file_origin='test.file',
testarg1=1, **params)
self.segment2 = Segment(name='test', description='tester 2',
file_origin='test.file',
testarg1=1, **params)
self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3])
self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3])
self.segment1.analogsignals = self.sig1
self.segment2.analogsignals = self.sig2
self.segment1.analogsignalarrays = self.sigarr1
self.segment2.analogsignalarrays = self.sigarr2
self.segment1.epochs = self.epoch1
self.segment2.epochs = self.epoch2
self.segment1.epocharrays = self.epocharr1
self.segment2.epocharrays = self.epocharr2
self.segment1.events = self.event1
self.segment2.events = self.event2
self.segment1.eventarrays = self.eventarr1
self.segment2.eventarrays = self.eventarr2
self.segment1.irregularlysampledsignals = self.irsig1
self.segment2.irregularlysampledsignals = self.irsig2
self.segment1.spikes = self.spike1
self.segment2.spikes = self.spike2
self.segment1.spiketrains = self.train1
self.segment2.spiketrains = self.train2
self.segment1.create_many_to_one_relationship()
self.segment2.create_many_to_one_relationship()
def setup_units(self):
params = {'testarg2': 'yes', 'testarg3': True}
self.unit1 = Unit(name='test', description='tester 1',
file_origin='test.file',
channel_indexes=np.array([1]),
testarg1=1, **params)
self.unit2 = Unit(name='test', description='tester 2',
file_origin='test.file',
channel_indexes=np.array([2]),
testarg1=1, **params)
self.unit1.annotate(testarg1=1.1, testarg0=[1, 2, 3])
self.unit2.annotate(testarg11=1.1, testarg10=[1, 2, 3])
self.unit1train = [self.train1[0], self.train2[1]]
self.unit2train = [self.train1[1], self.train2[0]]
self.unit1.spiketrains = self.unit1train
self.unit2.spiketrains = self.unit2train
self.unit1spike = [self.spike1[0], self.spike2[1]]
self.unit2spike = [self.spike1[1], self.spike2[0]]
self.unit1.spikes = self.unit1spike
self.unit2.spikes = self.unit2spike
self.unit1.create_many_to_one_relationship()
self.unit2.create_many_to_one_relationship()
def setup_analogsignals(self):
signame11 = 'analogsignal 1 1'
signame12 = 'analogsignal 1 2'
signame21 = 'analogsignal 2 1'
signame22 = 'analogsignal 2 2'
sigdata11 = np.arange(0, 10) * pq.mV
sigdata12 = np.arange(10, 20) * pq.mV
sigdata21 = np.arange(20, 30) * pq.V
sigdata22 = np.arange(30, 40) * pq.V
self.signames1 = [signame11, signame12]
self.signames2 = [signame21, signame22]
self.signames = [signame11, signame12, signame21, signame22]
sig11 = AnalogSignal(sigdata11, name=signame11,
channel_index=1, sampling_rate=1*pq.Hz)
sig12 = AnalogSignal(sigdata12, name=signame12,
channel_index=2, sampling_rate=1*pq.Hz)
sig21 = AnalogSignal(sigdata21, name=signame21,
channel_index=1, sampling_rate=1*pq.Hz)
sig22 = AnalogSignal(sigdata22, name=signame22,
channel_index=2, sampling_rate=1*pq.Hz)
self.sig1 = [sig11, sig12]
self.sig2 = [sig21, sig22]
self.sig = [sig11, sig12, sig21, sig22]
self.chan1sig = [self.sig1[0], self.sig2[0]]
self.chan2sig = [self.sig1[1], self.sig2[1]]
def setup_analogsignalarrays(self):
sigarrname11 = 'analogsignalarray 1 1'
sigarrname12 = 'analogsignalarray 1 2'
sigarrname21 = 'analogsignalarray 2 1'
sigarrname22 = 'analogsignalarray 2 2'
sigarrdata11 = np.arange(0, 10).reshape(5, 2) * pq.mV
sigarrdata12 = np.arange(10, 20).reshape(5, 2) * pq.mV
sigarrdata21 = np.arange(20, 30).reshape(5, 2) * pq.V
sigarrdata22 = np.arange(30, 40).reshape(5, 2) * pq.V
sigarrdata112 = np.hstack([sigarrdata11, sigarrdata11]) * pq.mV
self.sigarrnames1 = [sigarrname11, sigarrname12]
self.sigarrnames2 = [sigarrname21, sigarrname22, sigarrname11]
self.sigarrnames = [sigarrname11, sigarrname12,
sigarrname21, sigarrname22]
sigarr11 = AnalogSignalArray(sigarrdata11, name=sigarrname11,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
sigarr12 = AnalogSignalArray(sigarrdata12, name=sigarrname12,
sampling_rate=1*pq.Hz,
channel_index=np.array([2, 1]))
sigarr21 = AnalogSignalArray(sigarrdata21, name=sigarrname21,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
sigarr22 = AnalogSignalArray(sigarrdata22, name=sigarrname22,
sampling_rate=1*pq.Hz,
channel_index=np.array([2, 1]))
sigarr23 = AnalogSignalArray(sigarrdata11, name=sigarrname11,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
sigarr112 = AnalogSignalArray(sigarrdata112, name=sigarrname11,
sampling_rate=1*pq.Hz,
channel_index=np.array([1, 2]))
self.sigarr1 = [sigarr11, sigarr12]
self.sigarr2 = [sigarr21, sigarr22, sigarr23]
self.sigarr = [sigarr112, sigarr12, sigarr21, sigarr22]
self.chan1sigarr1 = [sigarr11[:, 0:1], sigarr12[:, 1:2]]
self.chan2sigarr1 = [sigarr11[:, 1:2], sigarr12[:, 0:1]]
self.chan1sigarr2 = [sigarr21[:, 0:1], sigarr22[:, 1:2],
sigarr23[:, 0:1]]
self.chan2sigarr2 = [sigarr21[:, 1:2], sigarr22[:, 0:1],
sigarr23[:, 0:1]]
def setup_epochs(self):
epochname11 = 'epoch 1 1'
epochname12 = 'epoch 1 2'
epochname21 = 'epoch 2 1'
epochname22 = 'epoch 2 2'
epochtime11 = 10 * pq.ms
epochtime12 = 20 * pq.ms
epochtime21 = 30 * pq.s
epochtime22 = 40 * pq.s
epochdur11 = 11 * pq.s
epochdur12 = 21 * pq.s
epochdur21 = 31 * pq.ms
epochdur22 = 41 * pq.ms
self.epochnames1 = [epochname11, epochname12]
self.epochnames2 = [epochname21, epochname22]
self.epochnames = [epochname11, epochname12, epochname21, epochname22]
epoch11 = Epoch(epochtime11, epochdur11,
label=epochname11, name=epochname11, channel_index=1,
testattr=True)
epoch12 = Epoch(epochtime12, epochdur12,
label=epochname12, name=epochname12, channel_index=2,
testattr=False)
epoch21 = Epoch(epochtime21, epochdur21,
label=epochname21, name=epochname21, channel_index=1)
epoch22 = Epoch(epochtime22, epochdur22,
label=epochname22, name=epochname22, channel_index=2)
self.epoch1 = [epoch11, epoch12]
self.epoch2 = [epoch21, epoch22]
self.epoch = [epoch11, epoch12, epoch21, epoch22]
def setup_epocharrays(self):
epocharrname11 = 'epocharr 1 1'
epocharrname12 = 'epocharr 1 2'
epocharrname21 = 'epocharr 2 1'
epocharrname22 = 'epocharr 2 2'
epocharrtime11 = np.arange(0, 10) * pq.ms
epocharrtime12 = np.arange(10, 20) * pq.ms
epocharrtime21 = np.arange(20, 30) * pq.s
epocharrtime22 = np.arange(30, 40) * pq.s
epocharrdur11 = np.arange(1, 11) * pq.s
epocharrdur12 = np.arange(11, 21) * pq.s
epocharrdur21 = np.arange(21, 31) * pq.ms
epocharrdur22 = np.arange(31, 41) * pq.ms
self.epocharrnames1 = [epocharrname11, epocharrname12]
self.epocharrnames2 = [epocharrname21, epocharrname22]
self.epocharrnames = [epocharrname11,
epocharrname12, epocharrname21, epocharrname22]
epocharr11 = EpochArray(epocharrtime11, epocharrdur11,
label=epocharrname11, name=epocharrname11)
epocharr12 = EpochArray(epocharrtime12, epocharrdur12,
label=epocharrname12, name=epocharrname12)
epocharr21 = EpochArray(epocharrtime21, epocharrdur21,
label=epocharrname21, name=epocharrname21)
epocharr22 = EpochArray(epocharrtime22, epocharrdur22,
label=epocharrname22, name=epocharrname22)
self.epocharr1 = [epocharr11, epocharr12]
self.epocharr2 = [epocharr21, epocharr22]
self.epocharr = [epocharr11, epocharr12, epocharr21, epocharr22]
def setup_events(self):
eventname11 = 'event 1 1'
eventname12 = 'event 1 2'
eventname21 = 'event 2 1'
eventname22 = 'event 2 2'
eventtime11 = 10 * pq.ms
eventtime12 = 20 * pq.ms
eventtime21 = 30 * pq.s
eventtime22 = 40 * pq.s
self.eventnames1 = [eventname11, eventname12]
self.eventnames2 = [eventname21, eventname22]
self.eventnames = [eventname11, eventname12, eventname21, eventname22]
params1 = {'testattr': True}
params2 = {'testattr': 5}
event11 = Event(eventtime11, label=eventname11, name=eventname11,
**params1)
event12 = Event(eventtime12, label=eventname12, name=eventname12,
**params2)
event21 = Event(eventtime21, label=eventname21, name=eventname21)
event22 = Event(eventtime22, label=eventname22, name=eventname22)
self.event1 = [event11, event12]
self.event2 = [event21, event22]
self.event = [event11, event12, event21, event22]
def setup_eventarrays(self):
eventarrname11 = 'eventarr 1 1'
eventarrname12 = 'eventarr 1 2'
eventarrname21 = 'eventarr 2 1'
eventarrname22 = 'eventarr 2 2'
eventarrtime11 = np.arange(0, 10) * pq.ms
eventarrtime12 = np.arange(10, 20) * pq.ms
eventarrtime21 = np.arange(20, 30) * pq.s
eventarrtime22 = np.arange(30, 40) * pq.s
self.eventarrnames1 = [eventarrname11, eventarrname12]
self.eventarrnames2 = [eventarrname21, eventarrname22]
self.eventarrnames = [eventarrname11,
eventarrname12, eventarrname21, eventarrname22]
eventarr11 = EventArray(eventarrtime11,
label=eventarrname11, name=eventarrname11)
eventarr12 = EventArray(eventarrtime12,
label=eventarrname12, name=eventarrname12)
eventarr21 = EventArray(eventarrtime21,
label=eventarrname21, name=eventarrname21)
eventarr22 = EventArray(eventarrtime22,
label=eventarrname22, name=eventarrname22)
self.eventarr1 = [eventarr11, eventarr12]
self.eventarr2 = [eventarr21, eventarr22]
self.eventarr = [eventarr11, eventarr12, eventarr21, eventarr22]
def setup_irregularlysampledsignals(self):
irsigname11 = 'irregularsignal 1 1'
irsigname12 = 'irregularsignal 1 2'
irsigname21 = 'irregularsignal 2 1'
irsigname22 = 'irregularsignal 2 2'
irsigdata11 = np.arange(0, 10) * pq.mA
irsigdata12 = np.arange(10, 20) * pq.mA
irsigdata21 = np.arange(20, 30) * pq.A
irsigdata22 = np.arange(30, 40) * pq.A
irsigtimes11 = np.arange(0, 10) * pq.ms
irsigtimes12 = np.arange(10, 20) * pq.ms
irsigtimes21 = np.arange(20, 30) * pq.s
irsigtimes22 = np.arange(30, 40) * pq.s
self.irsignames1 = [irsigname11, irsigname12]
self.irsignames2 = [irsigname21, irsigname22]
self.irsignames = [irsigname11, irsigname12, irsigname21, irsigname22]
irsig11 = IrregularlySampledSignal(irsigtimes11, irsigdata11,
name=irsigname11)
irsig12 = IrregularlySampledSignal(irsigtimes12, irsigdata12,
name=irsigname12)
irsig21 = IrregularlySampledSignal(irsigtimes21, irsigdata21,
name=irsigname21)
irsig22 = IrregularlySampledSignal(irsigtimes22, irsigdata22,
name=irsigname22)
self.irsig1 = [irsig11, irsig12]
self.irsig2 = [irsig21, irsig22]
self.irsig = [irsig11, irsig12, irsig21, irsig22]
def setup_spikes(self):
spikename11 = 'spike 1 1'
spikename12 = 'spike 1 2'
spikename21 = 'spike 2 1'
spikename22 = 'spike 2 2'
spikedata11 = 10 * pq.ms
spikedata12 = 20 * pq.ms
spikedata21 = 30 * pq.s
spikedata22 = 40 * pq.s
self.spikenames1 = [spikename11, spikename12]
self.spikenames2 = [spikename21, spikename22]
self.spikenames = [spikename11, spikename12, spikename21, spikename22]
spike11 = Spike(spikedata11, t_stop=100*pq.s, name=spikename11)
spike12 = Spike(spikedata12, t_stop=100*pq.s, name=spikename12)
spike21 = Spike(spikedata21, t_stop=100*pq.s, name=spikename21)
spike22 = Spike(spikedata22, t_stop=100*pq.s, name=spikename22)
self.spike1 = [spike11, spike12]
self.spike2 = [spike21, spike22]
self.spike = [spike11, spike12, spike21, spike22]
def setup_spiketrains(self):
trainname11 = 'spiketrain 1 1'
trainname12 = 'spiketrain 1 2'
trainname21 = 'spiketrain 2 1'
trainname22 = 'spiketrain 2 2'
traindata11 = np.arange(0, 10) * pq.ms
traindata12 = np.arange(10, 20) * pq.ms
traindata21 = np.arange(20, 30) * pq.s
traindata22 = np.arange(30, 40) * pq.s
self.trainnames1 = [trainname11, trainname12]
self.trainnames2 = [trainname21, trainname22]
self.trainnames = [trainname11, trainname12, trainname21, trainname22]
train11 = SpikeTrain(traindata11, t_stop=100*pq.s, name=trainname11)
train12 = SpikeTrain(traindata12, t_stop=100*pq.s, name=trainname12)
train21 = SpikeTrain(traindata21, t_stop=100*pq.s, name=trainname21)
train22 = SpikeTrain(traindata22, t_stop=100*pq.s, name=trainname22)
self.train1 = [train11, train12]
self.train2 = [train21, train22]
self.train = [train11, train12, train21, train22]
def test_init(self):
seg = Segment(name='a segment', index=3)
assert_neo_object_is_compliant(seg)
self.assertEqual(seg.name, 'a segment')
self.assertEqual(seg.file_origin, None)
self.assertEqual(seg.index, 3)
def test__construct_subsegment_by_unit(self):
nb_seg = 3
nb_unit = 7
unit_with_sig = np.array([0, 2, 5])
signal_types = ['Vm', 'Conductances']
sig_len = 100
#recordingchannelgroups
rcgs = [RecordingChannelGroup(name='Vm',
channel_indexes=unit_with_sig),
RecordingChannelGroup(name='Conductance',
channel_indexes=unit_with_sig)]
# Unit
all_unit = []
for u in range(nb_unit):
un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u]))
assert_neo_object_is_compliant(un)
all_unit.append(un)
blk = Block()
blk.recordingchannelgroups = rcgs
for s in range(nb_seg):
seg = Segment(name='Simulation %s' % s)
for j in range(nb_unit):
st = SpikeTrain([1, 2, 3], units='ms',
t_start=0., t_stop=10)
st.unit = all_unit[j]
for t in signal_types:
anasigarr = AnalogSignalArray(np.zeros((sig_len,
len(unit_with_sig))),
units='nA',
sampling_rate=1000.*pq.Hz,
channel_indexes=unit_with_sig)
seg.analogsignalarrays.append(anasigarr)
blk.create_many_to_one_relationship()
for unit in all_unit:
assert_neo_object_is_compliant(unit)
for rcg in rcgs:
assert_neo_object_is_compliant(rcg)
assert_neo_object_is_compliant(blk)
# what you want
newseg = seg.construct_subsegment_by_unit(all_unit[:4])
assert_neo_object_is_compliant(newseg)
def test_segment_creation(self):
assert_neo_object_is_compliant(self.segment1)
assert_neo_object_is_compliant(self.segment2)
assert_neo_object_is_compliant(self.unit1)
assert_neo_object_is_compliant(self.unit2)
self.assertEqual(self.segment1.name, 'test')
self.assertEqual(self.segment2.name, 'test')
self.assertEqual(self.segment1.description, 'tester 1')
self.assertEqual(self.segment2.description, 'tester 2')
self.assertEqual(self.segment1.file_origin, 'test.file')
self.assertEqual(self.segment2.file_origin, 'test.file')
self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3])
self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3])
self.assertEqual(self.segment1.annotations['testarg1'], 1.1)
self.assertEqual(self.segment2.annotations['testarg1'], 1)
self.assertEqual(self.segment2.annotations['testarg11'], 1.1)
self.assertEqual(self.segment1.annotations['testarg2'], 'yes')
self.assertEqual(self.segment2.annotations['testarg2'], 'yes')
self.assertTrue(self.segment1.annotations['testarg3'])
self.assertTrue(self.segment2.annotations['testarg3'])
self.assertTrue(hasattr(self.segment1, 'analogsignals'))
self.assertTrue(hasattr(self.segment2, 'analogsignals'))
self.assertEqual(len(self.segment1.analogsignals), 2)
self.assertEqual(len(self.segment2.analogsignals), 2)
for res, targ in zip(self.segment1.analogsignals, self.sig1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignals, self.sig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'analogsignalarrays'))
self.assertTrue(hasattr(self.segment2, 'analogsignalarrays'))
self.assertEqual(len(self.segment1.analogsignalarrays), 2)
self.assertEqual(len(self.segment2.analogsignalarrays), 3)
for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epochs'))
self.assertTrue(hasattr(self.segment2, 'epochs'))
self.assertEqual(len(self.segment1.epochs), 2)
self.assertEqual(len(self.segment2.epochs), 2)
for res, targ in zip(self.segment1.epochs, self.epoch1):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epochs, self.epoch2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epocharrays'))
self.assertTrue(hasattr(self.segment2, 'epocharrays'))
self.assertEqual(len(self.segment1.epocharrays), 2)
self.assertEqual(len(self.segment2.epocharrays), 2)
for res, targ in zip(self.segment1.epocharrays, self.epocharr1):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epocharrays, self.epocharr2):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'events'))
self.assertTrue(hasattr(self.segment2, 'events'))
self.assertEqual(len(self.segment1.events), 2)
self.assertEqual(len(self.segment2.events), 2)
for res, targ in zip(self.segment1.events, self.event1):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.events, self.event2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'eventarrays'))
self.assertTrue(hasattr(self.segment2, 'eventarrays'))
self.assertEqual(len(self.segment1.eventarrays), 2)
self.assertEqual(len(self.segment2.eventarrays), 2)
for res, targ in zip(self.segment1.eventarrays, self.eventarr1):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.eventarrays, self.eventarr2):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals'))
self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals'))
self.assertEqual(len(self.segment1.irregularlysampledsignals), 2)
self.assertEqual(len(self.segment2.irregularlysampledsignals), 2)
for res, targ in zip(self.segment1.irregularlysampledsignals,
self.irsig1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.irregularlysampledsignals,
self.irsig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spikes'))
self.assertTrue(hasattr(self.segment2, 'spikes'))
self.assertEqual(len(self.segment1.spikes), 2)
self.assertEqual(len(self.segment2.spikes), 2)
for res, targ in zip(self.segment1.spikes, self.spike1):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spikes, self.spike2):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spiketrains'))
self.assertTrue(hasattr(self.segment2, 'spiketrains'))
self.assertEqual(len(self.segment1.spiketrains), 2)
self.assertEqual(len(self.segment2.spiketrains), 2)
for res, targ in zip(self.segment1.spiketrains, self.train1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spiketrains, self.train2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_merge(self):
self.segment1.merge(self.segment2)
self.segment1.create_many_to_one_relationship(force=True)
assert_neo_object_is_compliant(self.segment1)
self.assertEqual(self.segment1.name, 'test')
self.assertEqual(self.segment2.name, 'test')
self.assertEqual(self.segment1.description, 'tester 1')
self.assertEqual(self.segment2.description, 'tester 2')
self.assertEqual(self.segment1.file_origin, 'test.file')
self.assertEqual(self.segment2.file_origin, 'test.file')
self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3])
self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3])
self.assertEqual(self.segment1.annotations['testarg1'], 1.1)
self.assertEqual(self.segment2.annotations['testarg1'], 1)
self.assertEqual(self.segment2.annotations['testarg11'], 1.1)
self.assertEqual(self.segment1.annotations['testarg2'], 'yes')
self.assertEqual(self.segment2.annotations['testarg2'], 'yes')
self.assertTrue(self.segment1.annotations['testarg3'])
self.assertTrue(self.segment2.annotations['testarg3'])
self.assertTrue(hasattr(self.segment1, 'analogsignals'))
self.assertTrue(hasattr(self.segment2, 'analogsignals'))
self.assertEqual(len(self.segment1.analogsignals), 4)
self.assertEqual(len(self.segment2.analogsignals), 2)
for res, targ in zip(self.segment1.analogsignals, self.sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignals, self.sig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'analogsignalarrays'))
self.assertTrue(hasattr(self.segment2, 'analogsignalarrays'))
self.assertEqual(len(self.segment1.analogsignalarrays), 4)
self.assertEqual(len(self.segment2.analogsignalarrays), 3)
for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epochs'))
self.assertTrue(hasattr(self.segment2, 'epochs'))
self.assertEqual(len(self.segment1.epochs), 4)
self.assertEqual(len(self.segment2.epochs), 2)
for res, targ in zip(self.segment1.epochs, self.epoch):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epochs, self.epoch2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.duration, targ.duration)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'epocharrays'))
self.assertTrue(hasattr(self.segment2, 'epocharrays'))
self.assertEqual(len(self.segment1.epocharrays), 4)
self.assertEqual(len(self.segment2.epocharrays), 2)
for res, targ in zip(self.segment1.epocharrays, self.epocharr):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.epocharrays, self.epocharr2):
assert_arrays_equal(res.times, targ.times)
assert_arrays_equal(res.durations, targ.durations)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'events'))
self.assertTrue(hasattr(self.segment2, 'events'))
self.assertEqual(len(self.segment1.events), 4)
self.assertEqual(len(self.segment2.events), 2)
for res, targ in zip(self.segment1.events, self.event):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.events, self.event2):
self.assertEqual(res.time, targ.time)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'eventarrays'))
self.assertTrue(hasattr(self.segment2, 'eventarrays'))
self.assertEqual(len(self.segment1.eventarrays), 4)
self.assertEqual(len(self.segment2.eventarrays), 2)
for res, targ in zip(self.segment1.eventarrays, self.eventarr):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.eventarrays, self.eventarr2):
assert_arrays_equal(res.times, targ.times)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals'))
self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals'))
self.assertEqual(len(self.segment1.irregularlysampledsignals), 4)
self.assertEqual(len(self.segment2.irregularlysampledsignals), 2)
for res, targ in zip(self.segment1.irregularlysampledsignals,
self.irsig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.irregularlysampledsignals,
self.irsig2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spikes'))
self.assertTrue(hasattr(self.segment2, 'spikes'))
self.assertEqual(len(self.segment1.spikes), 4)
self.assertEqual(len(self.segment2.spikes), 2)
for res, targ in zip(self.segment1.spikes, self.spike):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spikes, self.spike2):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
self.assertTrue(hasattr(self.segment1, 'spiketrains'))
self.assertTrue(hasattr(self.segment2, 'spiketrains'))
self.assertEqual(len(self.segment1.spiketrains), 4)
self.assertEqual(len(self.segment2.spiketrains), 2)
for res, targ in zip(self.segment1.spiketrains, self.train):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(self.segment2.spiketrains, self.train2):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_all_data(self):
result1 = self.segment1.all_data
targs = (self.epoch1 + self.epocharr1 + self.event1 + self.eventarr1 +
self.sig1 + self.sigarr1 + self.irsig1 +
self.spike1 + self.train1)
for res, targ in zip(result1, targs):
if hasattr(res, 'ndim') and res.ndim:
assert_arrays_equal(res, targ)
else:
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_spikes_by_unit(self):
result1 = self.segment1.take_spikes_by_unit()
result21 = self.segment1.take_spikes_by_unit([self.unit1])
result22 = self.segment1.take_spikes_by_unit([self.unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.unit1spike):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.unit2spike):
self.assertEqual(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_spiketrains_by_unit(self):
result1 = self.segment1.take_spiketrains_by_unit()
result21 = self.segment1.take_spiketrains_by_unit([self.unit1])
result22 = self.segment1.take_spiketrains_by_unit([self.unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.unit1train):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.unit2train):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_analogsignal_by_unit(self):
result1 = self.segment1.take_analogsignal_by_unit()
result21 = self.segment1.take_analogsignal_by_unit([self.unit1])
result22 = self.segment1.take_analogsignal_by_unit([self.unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_analogsignal_by_channelindex(self):
result1 = self.segment1.take_analogsignal_by_channelindex()
result21 = self.segment1.take_analogsignal_by_channelindex([1])
result22 = self.segment1.take_analogsignal_by_channelindex([2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sig):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_slice_of_analogsignalarray_by_unit(self):
segment = self.segment1
unit1 = self.unit1
unit2 = self.unit2
result1 = segment.take_slice_of_analogsignalarray_by_unit()
result21 = segment.take_slice_of_analogsignalarray_by_unit([unit1])
result22 = segment.take_slice_of_analogsignalarray_by_unit([unit2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_take_slice_of_analogsignalarray_by_channelindex(self):
segment = self.segment1
result1 = segment.take_slice_of_analogsignalarray_by_channelindex()
result21 = segment.take_slice_of_analogsignalarray_by_channelindex([1])
result22 = segment.take_slice_of_analogsignalarray_by_channelindex([2])
self.assertEqual(result1, [])
for res, targ in zip(result21, self.chan1sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
for res, targ in zip(result22, self.chan2sigarr1):
assert_arrays_equal(res, targ)
self.assertEqual(res.name, targ.name)
def test_segment_size(self):
result1 = self.segment1.size()
targ1 = {"epochs": 2, "events": 2, "analogsignals": 2,
"irregularlysampledsignals": 2, "spikes": 2,
"spiketrains": 2, "epocharrays": 2, "eventarrays": 2,
"analogsignalarrays": 2}
self.assertEqual(result1, targ1)
def test_segment_filter(self):
result1 = self.segment1.filter()
result2 = self.segment1.filter(name='analogsignal 1 1')
result3 = self.segment1.filter(testattr=True)
self.assertEqual(result1, [])
self.assertEqual(len(result2), 1)
assert_arrays_equal(result2[0], self.sig1[0])
self.assertEqual(len(result3), 2)
self.assertEqual(result3[0], self.epoch1[0])
self.assertEqual(result3[1], self.event1[0])
def test__children(self):
blk = Block(name='block1')
blk.segments = [self.segment1]
blk.create_many_to_one_relationship()
self.assertEqual(self.segment1._container_child_objects, ())
self.assertEqual(self.segment1._data_child_objects,
('AnalogSignal', 'AnalogSignalArray',
'Epoch', 'EpochArray',
'Event', 'EventArray',
'IrregularlySampledSignal',
'Spike', 'SpikeTrain'))
self.assertEqual(self.segment1._single_parent_objects, ('Block',))
self.assertEqual(self.segment1._multi_child_objects, ())
self.assertEqual(self.segment1._multi_parent_objects, ())
self.assertEqual(self.segment1._child_properties, ())
self.assertEqual(self.segment1._single_child_objects,
('AnalogSignal', 'AnalogSignalArray',
'Epoch', 'EpochArray',
'Event', 'EventArray',
'IrregularlySampledSignal',
'Spike', 'SpikeTrain'))
self.assertEqual(self.segment1._container_child_containers, ())
self.assertEqual(self.segment1._data_child_containers,
('analogsignals', 'analogsignalarrays',
'epochs', 'epocharrays',
'events', 'eventarrays',
'irregularlysampledsignals',
'spikes', 'spiketrains'))
self.assertEqual(self.segment1._single_child_containers,
('analogsignals', 'analogsignalarrays',
'epochs', 'epocharrays',
'events', 'eventarrays',
'irregularlysampledsignals',
'spikes', 'spiketrains'))
self.assertEqual(self.segment1._single_parent_containers, ('block',))
self.assertEqual(self.segment1._multi_child_containers, ())
self.assertEqual(self.segment1._multi_parent_containers, ())
self.assertEqual(self.segment1._child_objects,
('AnalogSignal', 'AnalogSignalArray',
'Epoch', 'EpochArray',
'Event', 'EventArray',
'IrregularlySampledSignal',
'Spike', 'SpikeTrain'))
self.assertEqual(self.segment1._child_containers,
('analogsignals', 'analogsignalarrays',
'epochs', 'epocharrays',
'events', 'eventarrays',
'irregularlysampledsignals',
'spikes', 'spiketrains'))
self.assertEqual(self.segment1._parent_objects, ('Block',))
self.assertEqual(self.segment1._parent_containers, ('block',))
self.assertEqual(len(self.segment1.children),
(len(self.sig1) +
len(self.sigarr1) +
len(self.epoch1) +
len(self.epocharr1) +
len(self.event1) +
len(self.eventarr1) +
len(self.irsig1) +
len(self.spike1) +
len(self.train1)))
self.assertEqual(self.segment1.children[0].name, self.signames1[0])
self.assertEqual(self.segment1.children[1].name, self.signames1[1])
self.assertEqual(self.segment1.children[2].name, self.sigarrnames1[0])
self.assertEqual(self.segment1.children[3].name, self.sigarrnames1[1])
self.assertEqual(self.segment1.children[4].name, self.epochnames1[0])
self.assertEqual(self.segment1.children[5].name, self.epochnames1[1])
self.assertEqual(self.segment1.children[6].name,
self.epocharrnames1[0])
self.assertEqual(self.segment1.children[7].name,
self.epocharrnames1[1])
self.assertEqual(self.segment1.children[8].name, self.eventnames1[0])
self.assertEqual(self.segment1.children[9].name, self.eventnames1[1])
self.assertEqual(self.segment1.children[10].name,
self.eventarrnames1[0])
self.assertEqual(self.segment1.children[11].name,
self.eventarrnames1[1])
self.assertEqual(self.segment1.children[12].name, self.irsignames1[0])
self.assertEqual(self.segment1.children[13].name, self.irsignames1[1])
self.assertEqual(self.segment1.children[14].name, self.spikenames1[0])
self.assertEqual(self.segment1.children[15].name, self.spikenames1[1])
self.assertEqual(self.segment1.children[16].name, self.trainnames1[0])
self.assertEqual(self.segment1.children[17].name, self.trainnames1[1])
self.assertEqual(len(self.segment1.parents), 1)
self.assertEqual(self.segment1.parents[0].name, 'block1')
self.segment1.create_many_to_one_relationship()
self.segment1.create_many_to_many_relationship()
self.segment1.create_relationship()
assert_neo_object_is_compliant(self.segment1)
