def test__children(self):
segment = Segment(name='seg1')
segment.spikes = [self.spike1]
segment.create_many_to_one_relationship()
unit = Unit(name='unit1')
unit.spikes = [self.spike1]
unit.create_many_to_one_relationship()
self.assertEqual(self.spike1._single_parent_objects,
('Segment', 'Unit'))
self.assertEqual(self.spike1._multi_parent_objects, ())
self.assertEqual(self.spike1._single_parent_containers,
('segment', 'unit'))
self.assertEqual(self.spike1._multi_parent_containers, ())
self.assertEqual(self.spike1._parent_objects,
('Segment', 'Unit'))
self.assertEqual(self.spike1._parent_containers,
('segment', 'unit'))
self.assertEqual(len(self.spike1.parents), 2)
self.assertEqual(self.spike1.parents[0].name, 'seg1')
self.assertEqual(self.spike1.parents[1].name, 'unit1')
assert_neo_object_is_compliant(self.spike1)
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 proc_src_units(srcfile, filename):
'''Get the units in an src file that has been processed by the official
matlab function. See proc_src for details'''
rcg = RecordingChannelGroup(file_origin=filename)
un_unit = Unit(name='UnassignedSpikes',
file_origin=filename,
elliptic=[],
boundaries=[],
timestamp=[],
max_valid=[])
rcg.units.append(un_unit)
sortInfo = srcfile['sortInfo'][0, 0]
timeslice = sortInfo['timeslice'][0, 0]
maxValid = timeslice['maxValid'][0, 0]
cluster = timeslice['cluster'][0, 0]
if len(cluster):
maxValid = maxValid[0, 0]
elliptic = [res.flatten() for res in cluster['elliptic'].flatten()]
boundaries = [res.flatten() for res in cluster['boundaries'].flatten()]
fullclust = zip(elliptic, boundaries)
for ielliptic, iboundaries in fullclust:
unit = Unit(file_origin=filename,
boundaries=[iboundaries],
elliptic=[ielliptic],
timeStamp=[],
max_valid=[maxValid])
rcg.units.append(unit)
return rcg
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 _read_unit(self, node, parent):
attributes = self._get_standard_attributes(node)
spiketrains = []
for name, child_node in node["spiketrains"].items():
if "SpikeTrain" in name:
obj_ref = child_node.attrs["object_ref"]
spiketrains.append(self.object_refs[obj_ref])
unit = Unit(**attributes)
unit.channel_index = parent
unit.spiketrains = spiketrains
return unit
def _read_unit(self, node, parent):
attributes = self._get_standard_attributes(node)
spiketrains = []
for name, child_node in node["spiketrains"].items():
if "SpikeTrain" in name:
obj_ref = child_node.attrs["object_ref"]
spiketrains.append(self.object_refs[obj_ref])
unit = Unit(**attributes)
unit.channel_index = parent
unit.spiketrains = spiketrains
return unit
def read_channelindex(self,
path,
cascade=True,
lazy=False,
read_waveforms=True):
channel_group = self._exdir_directory[path]
group_id = channel_group.attrs['electrode_group_id']
chx = ChannelIndex(
name='Channel group {}'.format(group_id),
index=channel_group.attrs['electrode_idx'],
channel_ids=channel_group.attrs['electrode_identities'],
**{
'group_id': group_id,
'exdir_path': path
})
if 'LFP' in channel_group:
for lfp_group in channel_group['LFP'].values():
ana = self.read_analogsignal(lfp_group.name,
cascade=cascade,
lazy=lazy)
chx.analogsignals.append(ana)
ana.channel_index = chx
if 'MUA' in channel_group:
for mua_group in channel_group['MUA'].values():
ana = self.read_analogsignal(mua_group.name,
cascade=cascade,
lazy=lazy)
chx.analogsignals.append(ana)
ana.channel_index = chx
sptrs = []
if 'UnitTimes' in channel_group:
for unit_group in channel_group['UnitTimes'].values():
unit = self.read_unit(unit_group.name,
cascade=cascade,
lazy=lazy,
read_waveforms=read_waveforms)
unit.channel_index = chx
chx.units.append(unit)
sptr = unit.spiketrains[0]
sptr.channel_index = chx
elif 'EventWaveform' in channel_group:
sptr = self.read_spiketrain(channel_group['EventWaveform'].name,
cascade=cascade,
lazy=lazy,
read_waveforms=read_waveforms)
unit = Unit(name=sptr.name, **sptr.annotations)
unit.spiketrains.append(sptr)
unit.channel_index = chx
sptr.channel_index = chx
chx.units.append(unit)
return chx
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 create_all_annotated(cls):
times = cls.rquant(1, pq.s)
signal = cls.rquant(1, pq.V)
blk = Block()
blk.annotate(**cls.rdict(3))
cls.populate_dates(blk)
seg = Segment()
seg.annotate(**cls.rdict(4))
cls.populate_dates(seg)
blk.segments.append(seg)
asig = AnalogSignal(signal=signal, sampling_rate=pq.Hz)
asig.annotate(**cls.rdict(2))
seg.analogsignals.append(asig)
isig = IrregularlySampledSignal(times=times,
signal=signal,
time_units=pq.s)
isig.annotate(**cls.rdict(2))
seg.irregularlysampledsignals.append(isig)
epoch = Epoch(times=times, durations=times)
epoch.annotate(**cls.rdict(4))
seg.epochs.append(epoch)
event = Event(times=times)
event.annotate(**cls.rdict(4))
seg.events.append(event)
spiketrain = SpikeTrain(times=times, t_stop=pq.s, units=pq.s)
d = cls.rdict(6)
d["quantity"] = pq.Quantity(10, "mV")
d["qarray"] = pq.Quantity(range(10), "mA")
spiketrain.annotate(**d)
seg.spiketrains.append(spiketrain)
chx = ChannelIndex(name="achx", index=[1, 2], channel_ids=[0, 10])
chx.annotate(**cls.rdict(5))
blk.channel_indexes.append(chx)
unit = Unit()
unit.annotate(**cls.rdict(2))
chx.units.append(unit)
return blk
def read_block(self, lazy=False, cascade=True, **kargs):
'''
Reads a block from the simple spike data file "fname" generated
with BrainWare
'''
# there are no keyargs implemented to so far. If someone tries to pass
# them they are expecting them to do something or making a mistake,
# neither of which should pass silently
if kargs:
raise NotImplementedError('This method does not have any '
'argument implemented yet')
self._fsrc = None
self.__lazy = lazy
self._blk = Block(file_origin=self._filename)
block = self._blk
# if we aren't doing cascade, don't load anything
if not cascade:
return block
# create the objects to store other objects
chx = ChannelIndex(file_origin=self._filename,
index=np.array([], dtype=np.int))
self.__unit = Unit(file_origin=self._filename)
# load objects into their containers
block.channel_indexes.append(chx)
chx.units.append(self.__unit)
# initialize values
self.__t_stop = None
self.__params = None
self.__seg = None
self.__spiketimes = None
# open the file
with open(self._path, 'rb') as self._fsrc:
res = True
# while the file is not done keep reading segments
while res:
res = self.__read_id()
block.create_many_to_one_relationship()
# cleanup attributes
self._fsrc = None
self.__lazy = False
self._blk = None
self.__t_stop = None
self.__params = None
self.__seg = None
self.__spiketimes = None
return block
def setup_unit(self):
unitname11 = 'unit 1 1'
unitname12 = 'unit 1 2'
unitname21 = 'unit 2 1'
unitname22 = 'unit 2 2'
self.unitnames1 = [unitname11, unitname12]
self.unitnames2 = [unitname21, unitname22, unitname11]
self.unitnames = [unitname11, unitname12, unitname21, unitname22]
unit11 = Unit(name=unitname11, channel_indexes=np.array([1]))
unit12 = Unit(name=unitname12, channel_indexes=np.array([2]))
unit21 = Unit(name=unitname21, channel_indexes=np.array([1]))
unit22 = Unit(name=unitname22, channel_indexes=np.array([2]))
unit23 = Unit(name=unitname11, channel_indexes=np.array([1]))
self.units1 = [unit11, unit12]
self.units2 = [unit21, unit22, unit23]
self.units = [unit11, unit12, unit21, unit22]
def create_all_annotated(cls):
times = cls.rquant(1, pq.s)
signal = cls.rquant(1, pq.V)
blk = Block()
blk.annotate(**cls.rdict(3))
seg = Segment()
seg.annotate(**cls.rdict(4))
blk.segments.append(seg)
asig = AnalogSignal(signal=signal, sampling_rate=pq.Hz)
asig.annotate(**cls.rdict(2))
seg.analogsignals.append(asig)
isig = IrregularlySampledSignal(times=times, signal=signal,
time_units=pq.s)
isig.annotate(**cls.rdict(2))
seg.irregularlysampledsignals.append(isig)
epoch = Epoch(times=times, durations=times)
epoch.annotate(**cls.rdict(4))
seg.epochs.append(epoch)
event = Event(times=times)
event.annotate(**cls.rdict(4))
seg.events.append(event)
spiketrain = SpikeTrain(times=times, t_stop=pq.s, units=pq.s)
d = cls.rdict(6)
d["quantity"] = pq.Quantity(10, "mV")
d["qarray"] = pq.Quantity(range(10), "mA")
spiketrain.annotate(**d)
seg.spiketrains.append(spiketrain)
chx = ChannelIndex(name="achx", index=[1, 2], channel_ids=[0, 10])
chx.annotate(**cls.rdict(5))
blk.channel_indexes.append(chx)
unit = Unit()
unit.annotate(**cls.rdict(2))
chx.units.append(unit)
return blk
def read_unit(fh, block_id, rcg_source_id, unit_id):
def read_spiketrains(nix_file):
strains = filter(lambda x: x.type == 'spiketrain', nix_file.blocks[block_id].data_arrays)
strains = [x for x in strains if nsn in [y.name for y in x.sources]]
return [Reader.read_spiketrain(fh, block_id, da.name) for da in strains]
nix_block = fh.handle.blocks[block_id]
nix_rcg_source = nix_block.sources[rcg_source_id]
nix_source = nix_rcg_source.sources[unit_id]
nsn = nix_source.name
rcg = Unit(nix_source.name)
for key, value in Reader.Help.read_attributes(nix_source.metadata, 'unit').items():
setattr(rcg, key, value)
rcg.annotations = Reader.Help.read_annotations(nix_source.metadata, 'unit')
setattr(rcg, 'spiketrains', ProxyList(fh, read_spiketrains))
return rcg
def test__children(self):
segment = Segment(name="seg1")
segment.spikes = [self.spike1]
segment.create_many_to_one_relationship()
unit = Unit(name="unit1")
unit.spikes = [self.spike1]
unit.create_many_to_one_relationship()
self.assertEqual(self.spike1._container_child_objects, ())
self.assertEqual(self.spike1._data_child_objects, ())
self.assertEqual(self.spike1._single_parent_objects, ("Segment", "Unit"))
self.assertEqual(self.spike1._multi_child_objects, ())
self.assertEqual(self.spike1._multi_parent_objects, ())
self.assertEqual(self.spike1._child_properties, ())
self.assertEqual(self.spike1._single_child_objects, ())
self.assertEqual(self.spike1._container_child_containers, ())
self.assertEqual(self.spike1._data_child_containers, ())
self.assertEqual(self.spike1._single_child_containers, ())
self.assertEqual(self.spike1._single_parent_containers, ("segment", "unit"))
self.assertEqual(self.spike1._multi_child_containers, ())
self.assertEqual(self.spike1._multi_parent_containers, ())
self.assertEqual(self.spike1._child_objects, ())
self.assertEqual(self.spike1._child_containers, ())
self.assertEqual(self.spike1._parent_objects, ("Segment", "Unit"))
self.assertEqual(self.spike1._parent_containers, ("segment", "unit"))
self.assertEqual(self.spike1.children, ())
self.assertEqual(len(self.spike1.parents), 2)
self.assertEqual(self.spike1.parents[0].name, "seg1")
self.assertEqual(self.spike1.parents[1].name, "unit1")
self.spike1.create_many_to_one_relationship()
self.spike1.create_many_to_many_relationship()
self.spike1.create_relationship()
assert_neo_object_is_compliant(self.spike1)
def read_unit(self,
path,
cascade=True,
lazy=False,
cluster_num=None,
read_waveforms=True):
group = self._exdir_directory[path]
assert group.parent.object_name == 'UnitTimes'
attrs = {'exdir_path': path}
attrs.update(group.attrs.to_dict())
unit = Unit(**attrs)
sptr = self.read_spiketrain(path, cascade, lazy, cluster_num,
read_waveforms)
unit.spiketrains.append(sptr)
return unit
def test_anonymous_objects_write(self):
nblocks = 2
nsegs = 2
nanasig = 4
nirrseg = 2
nepochs = 3
nevents = 4
nspiketrains = 3
nchx = 5
nunits = 10
times = self.rquant(1, pq.s)
signal = self.rquant(1, pq.V)
blocks = []
for blkidx in range(nblocks):
blk = Block()
blocks.append(blk)
for segidx in range(nsegs):
seg = Segment()
blk.segments.append(seg)
for anaidx in range(nanasig):
seg.analogsignals.append(AnalogSignal(signal=signal,
sampling_rate=pq.Hz))
for irridx in range(nirrseg):
seg.irregularlysampledsignals.append(
IrregularlySampledSignal(times=times,
signal=signal,
time_units=pq.s)
)
for epidx in range(nepochs):
seg.epochs.append(Epoch(times=times, durations=times))
for evidx in range(nevents):
seg.events.append(Event(times=times))
for stidx in range(nspiketrains):
seg.spiketrains.append(SpikeTrain(times=times,
t_stop=times[-1]+pq.s,
units=pq.s))
for chidx in range(nchx):
chx = ChannelIndex(name="chx{}".format(chidx),
index=[1, 2],
channel_ids=[11, 22])
blk.channel_indexes.append(chx)
for unidx in range(nunits):
unit = Unit()
chx.units.append(unit)
self.writer.write_all_blocks(blocks)
self.compare_blocks(blocks, self.reader.blocks)
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_multiref_write(self):
blk = Block("blk1")
signal = AnalogSignal(name="sig1",
signal=[0, 1, 2],
units="mV",
sampling_period=pq.Quantity(1, "ms"))
othersignal = IrregularlySampledSignal(name="i1",
signal=[0, 0, 0],
units="mV",
times=[1, 2, 3],
time_units="ms")
event = Event(name="Evee", times=[0.3, 0.42], units="year")
epoch = Epoch(name="epoche",
times=[0.1, 0.2] * pq.min,
durations=[0.5, 0.5] * pq.min)
st = SpikeTrain(name="the train of spikes",
times=[0.1, 0.2, 10.3],
t_stop=11,
units="us")
for idx in range(3):
segname = "seg" + str(idx)
seg = Segment(segname)
blk.segments.append(seg)
seg.analogsignals.append(signal)
seg.irregularlysampledsignals.append(othersignal)
seg.events.append(event)
seg.epochs.append(epoch)
seg.spiketrains.append(st)
chidx = ChannelIndex([10, 20, 29])
seg = blk.segments[0]
st = SpikeTrain(name="choochoo",
times=[10, 11, 80],
t_stop=1000,
units="s")
seg.spiketrains.append(st)
blk.channel_indexes.append(chidx)
for idx in range(6):
unit = Unit("unit" + str(idx))
chidx.units.append(unit)
unit.spiketrains.append(st)
self.writer.write_block(blk)
self.compare_blocks([blk], self.reader.blocks)
def read_block(self, lazy=False, cascade=True, load_waveforms=False):
"""
"""
# Create block
bl = Block(file_origin=self.filename)
if not cascade:
return bl
seg = self.read_segment(self.filename,
lazy=lazy,
cascade=cascade,
load_waveforms=load_waveforms)
bl.segments.append(seg)
neo.io.tools.populate_RecordingChannel(bl,
remove_from_annotation=False)
# This create rc and RCG for attaching Units
rcg0 = bl.recordingchannelgroups[0]
def find_rc(chan):
for rc in rcg0.recordingchannels:
if rc.index == chan:
return rc
for st in seg.spiketrains:
chan = st.annotations['channel_index']
rc = find_rc(chan)
if rc is None:
rc = RecordingChannel(index=chan)
rcg0.recordingchannels.append(rc)
rc.recordingchannelgroups.append(rcg0)
if len(rc.recordingchannelgroups) == 1:
rcg = RecordingChannelGroup(name='Group {}'.format(chan))
rcg.recordingchannels.append(rc)
rc.recordingchannelgroups.append(rcg)
bl.recordingchannelgroups.append(rcg)
else:
rcg = rc.recordingchannelgroups[1]
unit = Unit(name=st.name)
rcg.units.append(unit)
unit.spiketrains.append(st)
bl.create_many_to_one_relationship()
return bl
def test_no_segment_write(self):
# Tests storing AnalogSignal, IrregularlySampledSignal, and SpikeTrain
# objects in the secondary (ChannelIndex) substructure without them
# being attached to a Segment.
blk = Block("segmentless block")
signal = AnalogSignal(name="sig1",
signal=[0, 1, 2],
units="mV",
sampling_period=pq.Quantity(1, "ms"))
othersignal = IrregularlySampledSignal(name="i1",
signal=[0, 0, 0],
units="mV",
times=[1, 2, 3],
time_units="ms")
sta = SpikeTrain(name="the train of spikes",
times=[0.1, 0.2, 10.3],
t_stop=11,
units="us")
stb = SpikeTrain(name="the train of spikes b",
times=[1.1, 2.2, 10.1],
t_stop=100,
units="ms")
chidx = ChannelIndex([8, 13, 21])
blk.channel_indexes.append(chidx)
chidx.analogsignals.append(signal)
chidx.irregularlysampledsignals.append(othersignal)
unit = Unit()
chidx.units.append(unit)
unit.spiketrains.extend([sta, stb])
self.writer.write_block(blk)
self.compare_blocks([blk], self.reader.blocks)
self.writer.close()
reader = NixIO(self.filename, "ro")
blk = reader.read_block(neoname="segmentless block")
chx = blk.channel_indexes[0]
self.assertEqual(len(chx.analogsignals), 1)
self.assertEqual(len(chx.irregularlysampledsignals), 1)
self.assertEqual(len(chx.units[0].spiketrains), 2)
def test__issue_285(self):
train = SpikeTrain([3, 4, 5] * pq.s, t_stop=10.0)
unit = Unit()
train.unit = unit
unit.spiketrains.append(train)
epoch = Epoch([0, 10, 20], [2, 2, 2], ["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)
def test_multiref_write(self):
blk = Block("blk1")
signal = AnalogSignal(name="sig1", signal=[0, 1, 2], units="mV",
sampling_period=pq.Quantity(1, "ms"))
for idx in range(3):
segname = "seg" + str(idx)
seg = Segment(segname)
blk.segments.append(seg)
seg.analogsignals.append(signal)
chidx = ChannelIndex([10, 20, 29])
seg = blk.segments[0]
st = SpikeTrain(name="choochoo", times=[10, 11, 80], t_stop=1000,
units="s")
seg.spiketrains.append(st)
blk.channel_indexes.append(chidx)
for idx in range(6):
unit = Unit("unit" + str(idx))
chidx.units.append(unit)
unit.spiketrains.append(st)
self.writer.write_block(blk)
self.compare_blocks([blk], self.reader.blocks)
def read_block(self,
lazy=False,
cascade=True,
get_waveforms=True,
cluster_metadata='all',
raw_data_units='uV',
get_raw_data=False,
):
"""
Reads a block with segments and channel_indexes
Parameters:
get_waveforms: bool, default = False
Wether or not to get the waveforms
get_raw_data: bool, default = False
Wether or not to get the raw traces
raw_data_units: str, default = "uV"
SI units of the raw trace according to voltage_gain given to klusta
cluster_metadata: str, default = "all"
Which clusters to load, possibilities are "noise", "unsorted",
"good", "all", if all is selected noise is omitted.
"""
assert isinstance(cluster_metadata, str)
blk = Block()
if cascade:
seg = Segment(file_origin=self.filename)
blk.segments += [seg]
for model in self.models:
group_id = model.channel_group
group_meta = {'group_id': group_id}
group_meta.update(model.metadata)
chx = ChannelIndex(name='channel group #{}'.format(group_id),
index=model.channels,
**group_meta)
blk.channel_indexes.append(chx)
clusters = model.spike_clusters
for cluster_id in model.cluster_ids:
meta = model.cluster_metadata[cluster_id]
if cluster_metadata == 'all':
if meta == 'noise':
continue
elif cluster_metadata != meta:
continue
sptr = self.read_spiketrain(cluster_id=cluster_id,
model=model, lazy=lazy,
cascade=cascade,
get_waveforms=get_waveforms)
sptr.annotations.update({'cluster_metadata': meta,
'group_id': model.channel_group})
sptr.channel_index = chx
unit = Unit()
unit.spiketrains.append(sptr)
chx.units.append(unit)
unit.channel_index = chx
seg.spiketrains.append(sptr)
if get_raw_data:
ana = self.read_analogsignal(model, raw_data_units,
lazy, cascade)
ana.channel_index = chx
seg.analogsignals.append(ana)
seg.duration = model.duration * pq.s
blk.create_many_to_one_relationship()
return blk
def proc_f32(filename):
'''Load an f32 file that has already been processed by the official matlab
file converter. That matlab data is saved to an m-file, which is then
converted to a numpy '.npz' file. This numpy file is the file actually
loaded. This function converts it to a neo block and returns the block.
This block can be compared to the block produced by BrainwareF32IO to
make sure BrainwareF32IO is working properly
block = proc_f32(filename)
filename: The file name of the numpy file to load. It should end with
'*_f32_py?.npz'. This will be converted to a neo 'file_origin' property
with the value '*.f32', so the filename to compare should fit that pattern.
'py?' should be 'py2' for the python 2 version of the numpy file or 'py3'
for the python 3 version of the numpy file.
example: filename = 'file1_f32_py2.npz'
f32 file name = 'file1.f32'
'''
filenameorig = os.path.basename(filename[:-12] + '.f32')
# create the objects to store other objects
block = Block(file_origin=filenameorig)
chx = ChannelIndex(file_origin=filenameorig,
index=np.array([], dtype=np.int),
channel_names=np.array([], dtype='S'))
unit = Unit(file_origin=filenameorig)
# load objects into their containers
block.channel_indexes.append(chx)
chx.units.append(unit)
try:
with np.load(filename) as f32obj:
f32file = f32obj.items()[0][1].flatten()
except IOError as exc:
if 'as a pickle' in exc.message:
block.create_many_to_one_relationship()
return block
else:
raise
sweeplengths = [res[0, 0].tolist() for res in f32file['sweeplength']]
stims = [res.flatten().tolist() for res in f32file['stim']]
sweeps = [res['spikes'].flatten() for res in f32file['sweep'] if res.size]
fullf32 = zip(sweeplengths, stims, sweeps)
for sweeplength, stim, sweep in fullf32:
for trainpts in sweep:
if trainpts.size:
trainpts = trainpts.flatten().astype('float32')
else:
trainpts = []
paramnames = ['Param%s' % i for i in range(len(stim))]
params = dict(zip(paramnames, stim))
train = SpikeTrain(trainpts,
units=pq.ms,
t_start=0,
t_stop=sweeplength,
file_origin=filenameorig)
segment = Segment(file_origin=filenameorig, **params)
segment.spiketrains = [train]
unit.spiketrains.append(train)
block.segments.append(segment)
block.create_many_to_one_relationship()
return block
def setUp(self):
self.fname = '/tmp/test.exdir'
if os.path.exists(self.fname):
shutil.rmtree(self.fname)
self.n_channels = 5
self.n_samples = 20
self.n_spikes = 50
blk = Block()
seg = Segment()
blk.segments.append(seg)
chx1 = ChannelIndex(index=np.arange(self.n_channels),
channel_ids=np.arange(self.n_channels))
chx2 = ChannelIndex(index=np.arange(self.n_channels),
channel_ids=np.arange(self.n_channels) * 2)
blk.channel_indexes.extend([chx1, chx2])
wf1 = np.random.random(
(self.n_spikes, self.n_channels, self.n_samples))
ts1 = np.sort(np.random.random(self.n_spikes))
t_stop1 = np.ceil(ts1[-1])
sptr1 = SpikeTrain(
times=ts1,
units='s',
waveforms=np.random.random(
(self.n_spikes, self.n_channels, self.n_samples)) * pq.V,
name='spikes 1',
description='sptr1',
t_stop=t_stop1,
**{'id': 1})
sptr1.channel_index = chx1
unit1 = Unit(name='unit 1')
unit1.spiketrains.append(sptr1)
chx1.units.append(unit1)
seg.spiketrains.append(sptr1)
ts2 = np.sort(np.random.random(self.n_spikes))
t_stop2 = np.ceil(ts2[-1])
sptr2 = SpikeTrain(
times=ts2,
units='s',
waveforms=np.random.random(
(self.n_spikes, self.n_channels, self.n_samples)) * pq.V,
description='sptr2',
name='spikes 2',
t_stop=t_stop2,
**{'id': 2})
sptr2.channel_index = chx2
unit2 = Unit(name='unit 2')
unit2.spiketrains.append(sptr2)
chx2.units.append(unit2)
seg.spiketrains.append(sptr2)
wf3 = np.random.random(
(self.n_spikes, self.n_channels, self.n_samples))
ts3 = np.sort(np.random.random(self.n_spikes))
t_stop3 = np.ceil(ts3[-1])
sptr3 = SpikeTrain(
times=ts3,
units='s',
waveforms=np.random.random(
(self.n_spikes, self.n_channels, self.n_samples)) * pq.V,
description='sptr3',
name='spikes 3',
t_stop=t_stop3,
**{'id': 3})
sptr3.channel_index = chx2
unit3 = Unit(name='unit 3')
unit3.spiketrains.append(sptr3)
chx2.units.append(unit3)
seg.spiketrains.append(sptr3)
t_stop = max([t_stop1, t_stop2, t_stop3]) * pq.s
ana = AnalogSignal(np.random.random(self.n_samples),
sampling_rate=self.n_samples / t_stop,
units='V',
name='ana1',
description='LFP')
assert t_stop == ana.t_stop
seg.analogsignals.append(ana)
epo = Epoch(np.random.random(self.n_samples),
durations=[1] * self.n_samples * pq.s,
units='s',
name='epo1')
seg.epochs.append(epo)
self.blk = blk
def read_block(
self,
lazy=False,
get_waveforms=True,
cluster_group=None,
raw_data_units='uV',
get_raw_data=False,
):
"""
Reads a block with segments and channel_indexes
Parameters:
get_waveforms: bool, default = False
Wether or not to get the waveforms
get_raw_data: bool, default = False
Wether or not to get the raw traces
raw_data_units: str, default = "uV"
SI units of the raw trace according to voltage_gain given to klusta
cluster_group: str, default = None
Which clusters to load, possibilities are "noise", "unsorted",
"good", if None all is loaded.
"""
assert not lazy, 'Do not support lazy'
blk = Block()
seg = Segment(file_origin=self.filename)
blk.segments += [seg]
for model in self.models:
group_id = model.channel_group
group_meta = {'group_id': group_id}
group_meta.update(model.metadata)
chx = ChannelIndex(name='channel group #{}'.format(group_id),
index=model.channels,
**group_meta)
blk.channel_indexes.append(chx)
clusters = model.spike_clusters
for cluster_id in model.cluster_ids:
meta = model.cluster_metadata[cluster_id]
if cluster_group is None:
pass
elif cluster_group != meta:
continue
sptr = self.read_spiketrain(cluster_id=cluster_id,
model=model,
get_waveforms=get_waveforms,
raw_data_units=raw_data_units)
sptr.annotations.update({
'cluster_group': meta,
'group_id': model.channel_group
})
sptr.channel_index = chx
unit = Unit(cluster_group=meta,
group_id=model.channel_group,
name='unit #{}'.format(cluster_id))
unit.spiketrains.append(sptr)
chx.units.append(unit)
unit.channel_index = chx
seg.spiketrains.append(sptr)
if get_raw_data:
ana = self.read_analogsignal(model, units=raw_data_units)
ana.channel_index = chx
seg.analogsignals.append(ana)
seg.duration = model.duration * pq.s
blk.create_many_to_one_relationship()
return blk
def _source_unit_to_neo(self, nix_unit):
neo_attrs = self._nix_attr_to_neo(nix_unit)
neo_unit = Unit(**neo_attrs)
self._object_map[nix_unit.id] = neo_unit
return neo_unit
def read_spiketrain(self):
# TODO add parameter to allow user to read raw data or not?
assert (SpikeTrain in self.readable_objects)
spike_trains = []
channel_group_files = glob.glob(
os.path.join(self._path, self._base_filename) + ".[0-9]*")
for raw_filename in sorted(channel_group_files):
with open(raw_filename, "rb") as f:
params = parse_header_and_leave_cursor(f)
channel_group_index = int(raw_filename.split(".")[-1])
bytes_per_timestamp = params.get("bytes_per_timestamp", 4)
bytes_per_sample = params.get("bytes_per_sample", 1)
num_spikes = params.get("num_spikes", 0)
num_chans = params.get("num_chans", 1)
samples_per_spike = params.get("samples_per_spike", 50)
timebase = int(
params.get("timebase", "96000 hz").split(" ")[0]) * pq.Hz
sampling_rate = params.get("rawrate", 48000) * pq.Hz
bytes_per_spike_without_timestamp = samples_per_spike * bytes_per_sample
bytes_per_spike = bytes_per_spike_without_timestamp + bytes_per_timestamp
timestamp_dtype = ">u" + str(bytes_per_timestamp)
waveform_dtype = "<i" + str(bytes_per_sample)
dtype = np.dtype([("times", (timestamp_dtype, 1), 1),
("waveforms", (waveform_dtype, 1),
samples_per_spike)])
data = np.fromfile(f,
dtype=dtype,
count=num_spikes * num_chans)
assert_end_of_data(f)
# times are saved for each channel
times = data["times"][::num_chans] / timebase
assert len(times) == num_spikes
waveforms = data["waveforms"]
waveforms = np.reshape(waveforms,
(num_spikes, num_chans, samples_per_spike))
# TODO HACK !!!! findout if recording is sig - ref or the other
# way around, this determines the way of the peak which should be
# possible to set in a parameter e.g. peak='negative'/'positive'
waveforms = -waveforms.astype(float)
channel_gain_matrix = np.ones(waveforms.shape)
for i in range(num_chans):
channel_gain_matrix[:, i, :] *= self._channel_gain(
channel_group_index, i)
waveforms = scale_analog_signal(waveforms, channel_gain_matrix,
self._adc_fullscale,
bytes_per_sample)
# TODO get left_sweep form setfile?
spike_train = SpikeTrain(times,
t_stop=self._duration,
waveforms=waveforms * pq.uV,
sampling_rate=sampling_rate,
left_sweep=0.2 * pq.ms,
**params)
spike_trains.append(spike_train)
channel_index = self._channel_group_to_channel_index[
channel_group_index]
spike_train.channel_index = channel_index
unit = Unit(
) # TODO unit can have several spiketrains from different segments, not necessarily relevant here though
unit.spiketrains.append(spike_train)
channel_index.units.append(unit)
return spike_trains
def read_block(self, lazy=False, cascade=True):
"""Returns a Block containing spike information.
There is no obvious way to infer the segment boundaries from
raw spike times, so for now all spike times are returned in one
big segment. The way around this would be to specify the segment
boundaries, and then change this code to put the spikes in the right
segments.
"""
# Create block and segment to hold all the data
block = Block()
# Search data directory for KlustaKwik files.
# If nothing found, return empty block
self._fetfiles = self._fp.read_filenames('fet')
self._clufiles = self._fp.read_filenames('clu')
if len(self._fetfiles) == 0 or not cascade:
return block
# Create a single segment to hold all of the data
seg = Segment(name='seg0', index=0, file_origin=self.filename)
block.segments.append(seg)
# Load spike times from each group and store in a dict, keyed
# by group number
self.spiketrains = dict()
for group in sorted(self._fetfiles.keys()):
# Load spike times
fetfile = self._fetfiles[group]
spks, features = self._load_spike_times(fetfile)
# Load cluster ids or generate
if group in self._clufiles:
clufile = self._clufiles[group]
uids = self._load_unit_id(clufile)
else:
# unclustered data, assume all zeros
uids = np.zeros(spks.shape, dtype=np.int32)
# error check
if len(spks) != len(uids):
raise ValueError("lengths of fet and clu files are different")
# Create Unit for each cluster
unique_unit_ids = np.unique(uids)
for unit_id in sorted(unique_unit_ids):
# Initialize the unit
u = Unit(name=('unit %d from group %d' % (unit_id, group)),
index=unit_id,
group=group)
# Initialize a new SpikeTrain for the spikes from this unit
if lazy:
st = SpikeTrain(times=[],
units='sec',
t_start=0.0,
t_stop=spks.max() / self.sampling_rate,
name=('unit %d from group %d' %
(unit_id, group)))
st.lazy_shape = len(spks[uids == unit_id])
else:
st = SpikeTrain(
times=spks[uids == unit_id] / self.sampling_rate,
units='sec',
t_start=0.0,
t_stop=spks.max() / self.sampling_rate,
name=('unit %d from group %d' % (unit_id, group)))
st.annotations['cluster'] = unit_id
st.annotations['group'] = group
# put features in
if not lazy and len(features) != 0:
st.annotations['waveform_features'] = features
# Link
u.spiketrains.append(st)
seg.spiketrains.append(st)
block.create_many_to_one_relationship()
return block
def read_block(self,
block_index=0,
lazy=False,
signal_group_mode=None,
units_group_mode=None,
load_waveforms=False):
"""
:param block_index: int default 0. In case of several block block_index can be specified.
:param lazy: False by default.
:param signal_group_mode: 'split-all' or 'group-by-same-units' (default depend IO):
This control behavior for grouping channels in AnalogSignal.
* 'split-all': each channel will give an AnalogSignal
* 'group-by-same-units' all channel sharing the same quantity units ar grouped in
a 2D AnalogSignal
:param units_group_mode: 'split-all' or 'all-in-one'(default depend IO)
This control behavior for grouping Unit in ChannelIndex:
* 'split-all': each neo.Unit is assigned to a new neo.ChannelIndex
* 'all-in-one': all neo.Unit are grouped in the same neo.ChannelIndex
(global spike sorting for instance)
:param load_waveforms: False by default. Control SpikeTrains.waveforms is None or not.
"""
if signal_group_mode is None:
signal_group_mode = self._prefered_signal_group_mode
if self._prefered_signal_group_mode == 'split-all':
self.logger.warning("the default signal_group_mode will change from "\
"'split-all' to 'group-by-same-units' in next release")
if units_group_mode is None:
units_group_mode = self._prefered_units_group_mode
# annotations
bl_annotations = dict(self.raw_annotations['blocks'][block_index])
bl_annotations.pop('segments')
bl_annotations = check_annotations(bl_annotations)
bl = Block(**bl_annotations)
# ChannelIndex are plit in 2 parts:
# * some for AnalogSignals
# * some for Units
# ChannelIndex for AnalogSignals
all_channels = self.header['signal_channels']
channel_indexes_list = self.get_group_channel_indexes()
for channel_index in channel_indexes_list:
for i, (ind_within,
ind_abs) in self._make_signal_channel_subgroups(
channel_index,
signal_group_mode=signal_group_mode).items():
if signal_group_mode == "split-all":
chidx_annotations = self.raw_annotations[
'signal_channels'][i]
elif signal_group_mode == "group-by-same-units":
# this should be done with array_annotation soon:
keys = list(self.raw_annotations['signal_channels'][
ind_abs[0]].keys())
# take key from first channel of the group
chidx_annotations = {key: [] for key in keys}
for j in ind_abs:
for key in keys:
v = self.raw_annotations['signal_channels'][j].get(
key, None)
chidx_annotations[key].append(v)
if 'name' in list(chidx_annotations.keys()):
chidx_annotations.pop('name')
chidx_annotations = check_annotations(chidx_annotations)
# this should be done with array_annotation soon:
ch_names = all_channels[ind_abs]['name'].astype('S')
neo_channel_index = ChannelIndex(
index=ind_within,
channel_names=ch_names,
channel_ids=all_channels[ind_abs]['id'],
name='Channel group {}'.format(i),
**chidx_annotations)
bl.channel_indexes.append(neo_channel_index)
# ChannelIndex and Unit
# 2 case are possible in neo defifferent IO have choosen one or other:
# * All units are grouped in the same ChannelIndex and indexes are all channels:
# 'all-in-one'
# * Each units is assigned to one ChannelIndex: 'split-all'
# This is kept for compatibility
unit_channels = self.header['unit_channels']
if units_group_mode == 'all-in-one':
if unit_channels.size > 0:
channel_index = ChannelIndex(index=np.array([], dtype='i'),
name='ChannelIndex for all Unit')
bl.channel_indexes.append(channel_index)
for c in range(unit_channels.size):
unit_annotations = self.raw_annotations['unit_channels'][c]
unit_annotations = check_annotations(unit_annotations)
unit = Unit(**unit_annotations)
channel_index.units.append(unit)
elif units_group_mode == 'split-all':
for c in range(len(unit_channels)):
unit_annotations = self.raw_annotations['unit_channels'][c]
unit_annotations = check_annotations(unit_annotations)
unit = Unit(**unit_annotations)
channel_index = ChannelIndex(index=np.array([], dtype='i'),
name='ChannelIndex for Unit')
channel_index.units.append(unit)
bl.channel_indexes.append(channel_index)
# Read all segments
for seg_index in range(self.segment_count(block_index)):
seg = self.read_segment(block_index=block_index,
seg_index=seg_index,
lazy=lazy,
signal_group_mode=signal_group_mode,
load_waveforms=load_waveforms)
bl.segments.append(seg)
# create link to other containers ChannelIndex and Units
for seg in bl.segments:
for c, anasig in enumerate(seg.analogsignals):
bl.channel_indexes[c].analogsignals.append(anasig)
nsig = len(seg.analogsignals)
for c, sptr in enumerate(seg.spiketrains):
if units_group_mode == 'all-in-one':
bl.channel_indexes[nsig].units[c].spiketrains.append(sptr)
elif units_group_mode == 'split-all':
bl.channel_indexes[nsig +
c].units[0].spiketrains.append(sptr)
bl.create_many_to_one_relationship()
return bl
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])
def read_block(self, block_index=0, lazy=False, cascade=True, signal_group_mode=None,
units_group_mode=None, load_waveforms=False, time_slices=None):
"""
:param block_index: int default 0. In case of several block block_index can be specified.
:param lazy: False by default.
:param cascade: True by Default
:param signal_group_mode: 'split-all' or 'group-by-same-units' (default depend IO):
This control behavior for grouping channels in AnalogSignal.
* 'split-all': each channel will give an AnalogSignal
* 'group-by-same-units' all channel sharing the same quantity units ar grouped in
a 2D AnalogSignal
:param units_group_mode: 'split-all' or 'all-in-one'(default depend IO)
This control behavior for grouping Unit in ChannelIndex:
* 'split-all': each neo.Unit is assigned to a new neo.ChannelIndex
* 'all-in-one': all neo.Unit are grouped in the same neo.ChannelIndex (global spike sorting for instance)
:param load_waveforms: False by default. Control SpikeTrains.waveforms is None or not.
:param time_slices: None by default. List of time_slice. A time slice is (t_start, t_stop) both are quantities.
each element will lead to a fake neo.Segment. So len(block.segment) == len(time_slice)
all time_slice must be compatible with original time range.
"""
if signal_group_mode is None:
signal_group_mode = self._prefered_signal_group_mode
if units_group_mode is None:
units_group_mode = self._prefered_units_group_mode
#annotations
bl_annotations = dict(self.raw_annotations['blocks'][block_index])
bl_annotations.pop('segments')
bl_annotations = check_annotations(bl_annotations)
bl = Block(**bl_annotations)
if not cascade:
return bl
#ChannelIndex are plit in 2 parts:
# * some for AnalogSignals
# * some for Units
#ChannelIndex ofr AnalogSignals
all_channels = self.header['signal_channels']
channel_indexes_list = self.get_group_channel_indexes()
for channel_index in channel_indexes_list:
for i, (ind_within, ind_abs) in self._make_signal_channel_subgroups(channel_index,
signal_group_mode=signal_group_mode).items():
neo_channel_index = ChannelIndex(index=ind_within, channel_names=all_channels[ind_abs]['name'].astype('S'),
channel_ids=all_channels[ind_abs]['id'], name='Channel group {}'.format(i))
bl.channel_indexes.append(neo_channel_index)
#ChannelIndex and Unit
#2 case are possible in neo defifferent IO have choosen one or other:
# * All units are group in the same ChannelIndex and indexes are all channels : 'all-in-one'
# * Each units is assigned to one ChannelIndex : 'split-all'
# This is kept for compatibility
unit_channels = self.header['unit_channels']
if units_group_mode=='all-in-one':
if unit_channels.size>0:
channel_index = ChannelIndex(index=np.array([], dtype='i'),
name='ChannelIndex for all Unit')
bl.channel_indexes.append(channel_index)
for c in range(unit_channels.size):
unit_annotations = self.raw_annotations['unit_channels'][c]
unit = Unit(**unit_annotations)
channel_index.units.append(unit)
elif units_group_mode=='split-all':
for c in range(len(unit_channels)):
unit_annotations = self.raw_annotations['unit_channels'][c]
unit = Unit(**unit_annotations)
channel_index = ChannelIndex(index=np.array([], dtype='i'),
name='ChannelIndex for Unit')
channel_index.units.append(unit)
bl.channel_indexes.append(channel_index)
if time_slices is None:
#Read the real segment counts
for seg_index in range(self.segment_count(block_index)):
seg = self.read_segment(block_index=block_index, seg_index=seg_index,
lazy=lazy, cascade=cascade, signal_group_mode=signal_group_mode,
load_waveforms=load_waveforms)
bl.segments.append(seg)
else:
#return a fake segment list corresponding to time_slices
for s, time_slice in enumerate(time_slices):
#find in which segment time_slice is
t_start, t_stop = time_slice
t_start = ensure_second(t_start)
t_stop = ensure_second(t_stop)
related_seg_index = None
for seg_index in range(self.segment_count(block_index)):
seg_t_start = self.segment_t_start(block_index, seg_index) * pq.s
seg_t_stop = self.segment_t_stop(block_index, seg_index) * pq.s
if (seg_t_start<=t_start<=seg_t_stop) and (seg_t_start<=t_stop<=seg_t_stop):
related_seg_index = seg_index
if related_seg_index is None:
raise(ValueError('time_slice not in any segment range {}'.format(time_slice)))
seg = self.read_segment(block_index=block_index, seg_index=related_seg_index,
lazy=lazy, cascade=cascade, signal_group_mode=signal_group_mode,
load_waveforms=load_waveforms, time_slice=time_slice)
seg.index = s
bl.segments.append(seg)
for c, anasig in enumerate(seg.analogsignals):
bl.channel_indexes[c].analogsignals.append(anasig)
#create link to other containers ChannelIndex and Units
for seg in bl.segments:
for c, anasig in enumerate(seg.analogsignals):
bl.channel_indexes[c].analogsignals.append(anasig)
nsig = len(seg.analogsignals)
for c, sptr in enumerate(seg.spiketrains):
if units_group_mode=='all-in-one':
bl.channel_indexes[nsig].units[c].spiketrains.append(sptr)
elif units_group_mode=='split-all':
bl.channel_indexes[nsig+c].units[0].spiketrains.append(sptr)
bl.create_many_to_one_relationship()
return bl
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')
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)
