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 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 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