def __init__(self, phy_folder): SortingExtractor.__init__(self) phy_folder = Path(phy_folder) spike_times = np.load(phy_folder / 'spike_times.npy') spike_templates = np.load(phy_folder / 'spike_templates.npy') amplitudes = np.load(phy_folder / 'amplitudes.npy') pc_features = np.load(phy_folder / 'pc_features.npy') if (phy_folder / 'spike_clusters.npy').is_file(): spike_clusters = np.load(phy_folder / 'spike_clusters.npy') else: spike_clusters = spike_templates self._spiketrains = [] self._amps = [] self._pc_features = [] clust_id = np.unique(spike_clusters) self._unit_ids = list(clust_id) spike_times.astype(int) self._spiketrais = [] for clust in self._unit_ids: idx = np.where(spike_clusters == clust)[0] self._spiketrains.append(spike_times[idx]) self._amps.append(amplitudes[idx]) self._pc_features.append(pc_features[idx]) # set features for u_i, unit in enumerate(self.getUnitIds()): self.setUnitSpikeFeatures(unit, 'amplitudes', self._amps[u_i]) self.setUnitSpikeFeatures(unit, 'pc_features', self._pc_features[u_i])
def __init__(self, sorting, save_path=None): SortingExtractor.__init__( self) # init tmp folder before constructing NpzSortingExtractor tmp_folder = self.get_tmp_folder() self._sorting = sorting if save_path is None: self._is_tmp = True self._tmp_file = tempfile.NamedTemporaryFile(suffix=".npz", dir=tmp_folder).name else: save_path = Path(save_path) if save_path.suffix != '.npz': save_path = save_path.with_suffix('.npz') if not save_path.parent.is_dir(): os.makedirs(save_path.parent) self._is_tmp = False self._tmp_file = save_path NpzSortingExtractor.write_sorting(self._sorting, self._tmp_file) NpzSortingExtractor.__init__(self, self._tmp_file) # keep Npz kwargs self._npz_kwargs = deepcopy(self._kwargs) self.set_tmp_folder(tmp_folder) self.copy_unit_properties(sorting) self.copy_unit_spike_features(sorting) self._kwargs = {'sorting': sorting}
def add_sorting(self, *, recording_id: str, label: str, sorting: se.SortingExtractor): sorting_id = 'S-' + _random_id() if recording_id not in self._recordings: raise Exception(f'Recording not found: {recording_id}') if sorting_id in self._sortings: raise Exception(f'Duplicate sorting ID: {sorting_id}') le_recording = self._recordings[recording_id] x = { 'sortingId': sorting_id, 'sortingLabel': label, 'sortingPath': kp.store_object(sorting.object(), basename=f'{label}.json'), 'sortingObject': sorting.object(), 'recordingId': recording_id, 'recordingPath': le_recording['recordingPath'], 'recordingObject': le_recording['recordingObject'], 'description': f'Imported from Python: {label}' } sortings_subfeed = self._feed.get_subfeed( dict(workspaceName=self._workspace_name, key='sortings')) _import_le_sorting(sortings_subfeed, x) self._sortings[sorting_id] = x return x
def write_sorting(sorting: SortingExtractor, save_path: PathType): # if multiple groups, use the NeuroscopeMultiSortingExtactor write function if 'group' in sorting.get_shared_unit_property_names(): NeuroscopeMultiSortingExtractor.write_sorting(sorting, save_path) else: save_path.mkdir(parents=True, exist_ok=True) if save_path.suffix == '': sorting_name = save_path.name else: sorting_name = save_path.stem xml_name = sorting_name save_xml_filepath = save_path / (str(xml_name) + '.xml') # create parameters file if none exists if save_xml_filepath.is_file(): raise FileExistsError(f'{save_xml_filepath} already exists!') xml_root = et.Element('xml') et.SubElement(xml_root, 'acquisitionSystem') et.SubElement(xml_root.find('acquisitionSystem'), 'samplingRate') xml_root.find('acquisitionSystem').find('samplingRate').text = str( sorting.get_sampling_frequency()) et.ElementTree(xml_root).write(str(save_xml_filepath.absolute()), pretty_print=True) # Create and save .res and .clu files from the current sorting object save_res = save_path / f'{sorting_name}.res' save_clu = save_path / f'{sorting_name}.clu' res, clu = _extract_res_clu_arrays(sorting) np.savetxt(save_res, res, fmt='%i') np.savetxt(save_clu, clu, fmt='%i')
def __init__(self, folder_path, chan_grp=None): assert HAVE_TDC, self.installation_mesg tdc_folder = Path(folder_path) SortingExtractor.__init__(self) dataio = tdc.DataIO(str(tdc_folder)) if chan_grp is None: # if chan_grp is not provided, take the first one if unique chan_grps = list(dataio.channel_groups.keys()) assert len( chan_grps ) == 1, 'There are several groups in the folder, specify chan_grp=...' chan_grp = chan_grps[0] self.chan_grp = chan_grp catalogue = dataio.load_catalogue(name='initial', chan_grp=chan_grp) labels = catalogue['clusters']['cluster_label'] labels = labels[labels >= 0] self._unit_ids = list(labels) # load all spike in memory (this avoid to lock the folder with memmap throug dataio self._all_spikes = dataio.get_spikes(seg_num=0, chan_grp=self.chan_grp, i_start=None, i_stop=None).copy() self._sampling_frequency = dataio.sample_rate self._kwargs = { 'folder_path': str(Path(folder_path).absolute()), 'chan_grp': chan_grp }
def write_sorting(sorting: SortingExtractor, save_path: PathType): assert save_path.suffixes == [ ".spikes", ".cellinfo", ".mat", ], "The save_path must correspond to the CellExplorer format of sorting_id.spikes.cellinfo.mat!" base_path = save_path.parent sorting_id = save_path.name.split(".")[0] session_info_save_path = base_path / f"{sorting_id}.sessionInfo.mat" spikes_save_path = save_path base_path.mkdir(parents=True, exist_ok=True) sampling_frequency = sorting.get_sampling_frequency() session_info_mat_dict = dict(sessionInfo=dict(rates=dict( wideband=sampling_frequency))) scipy.io.savemat(file_name=session_info_save_path, mdict=session_info_mat_dict) spikes_mat_dict = dict(spikes=dict( UID=sorting.get_unit_ids(), times=[[[y / sampling_frequency] for y in x] for x in sorting.get_units_spike_train()], )) # If, in the future, it is ever desired to allow this to write unit properties, they must conform # to the format here: https://cellexplorer.org/datastructure/data-structure-and-format/ scipy.io.savemat(file_name=spikes_save_path, mdict=spikes_mat_dict)
def __init__(self, exdir_file, sample_rate=None): exdir, pq = _load_required_modules() SortingExtractor.__init__(self) self._exdir_file = exdir_file exdir_group = exdir.File(exdir_file, plugins=exdir.plugins.quantities) if 'acquisition' in exdir_group.keys(): if 'timeseries' in exdir_group['acquisition'].keys(): sample_rate = exdir_group['acquisition']['timeseries'].attrs['sample_rate'] else: if sample_rate is None: raise Exception("Provide 'sample_rate' argument (Hz)") else: sample_rate = sample_rate * pq.Hz electrophysiology = exdir_group['processing']['electrophysiology'] self._unit_ids = [] current_unit = 1 self._spike_trains = [] for chan_name, channel in electrophysiology.items(): group = int(chan_name.split('_')[-1]) for units, unit_times in channel['UnitTimes'].items(): self._unit_ids.append(current_unit) self._spike_trains.append((unit_times['times'].data.rescale('s')*sample_rate).magnitude) self.setUnitProperty(current_unit, 'group', group) current_unit += 1
def import_sorting(*, feed: kp.Feed, workspace_name: str, recording: se.RecordingExtractor, sorting: se.SortingExtractor, recording_id: str, sorting_label: str): sorting_id = 'S-' + random_id() x = { 'sortingId': sorting_id, 'sortingLabel': sorting_label, 'sortingPath': ka.store_object(sorting.object(), basename=f'{sorting_label}.json'), 'sortingObject': sorting.object(), 'recordingId': recording_id, 'recordingPath': ka.store_object(recording.object(), basename=f'{recording_id}.json'), 'recordingObject': recording.object(), 'description': f'Imported from Python: {sorting_label}' } sortings_subfeed = feed.get_subfeed( dict(workspaceName=workspace_name, key='sortings')) _import_le_sorting(sortings_subfeed, x) return x
def __init__(self, spikes_matfile_path: PathType): SortingExtractor.__init__(self) spikes_matfile_path = Path(spikes_matfile_path) assert spikes_matfile_path.is_file( ), f"The spikes_matfile_path ({spikes_matfile_path}) must exist!" folder_path = spikes_matfile_path.parent sorting_id = spikes_matfile_path.name.split(".")[0] session_info_matfile_path = folder_path / f"{sorting_id}.sessionInfo.mat" assert session_info_matfile_path.is_file( ), "No sessionInfo.mat file found in the folder!" session_info_mat = loadmat( file_name=str(session_info_matfile_path.absolute())) assert session_info_mat['sessionInfo']['rates'][0][0]['wideband'], "The sesssionInfo.mat file must contain " \ "a 'sessionInfo' struct with field 'rates' containing field 'wideband'!" self._sampling_frequency = float( session_info_mat['sessionInfo']['rates'][0][0]['wideband'][0][0][0] [0] ) # careful not to confuse it with the lfpsamplingrate; reported in units Hz spikes_mat = loadmat(file_name=str(spikes_matfile_path.absolute())) assert np.all(np.isin(['UID', 'times'], spikes_mat['spikes'].dtype.names)), \ "The spikes.cellinfo.mat file must contain a 'spikes' struct with fields 'UID' and 'times'!" self._unit_ids = np.asarray(spikes_mat['spikes']['UID'][0][0][0], dtype=int) # CellExplorer reports spike times in units seconds; SpikeExtractors uses time units of sampling frames # Rounding is necessary to prevent data loss from int-casting floating point errors self._spiketrains = [(np.array([y[0] for y in x]) * self._sampling_frequency).round().astype(int) for x in spikes_mat['spikes']['times'][0][0][0]] self._kwargs = dict( spikes_matfile_path=str(spikes_matfile_path.absolute()))
def __init__(self, parent_sorting, curation_steps=None): SortingExtractor.__init__(self) self._parent_sorting = parent_sorting self._original_unit_ids = list(np.copy(parent_sorting.get_unit_ids())) self._all_ids = list(np.copy(parent_sorting.get_unit_ids())) self._sampling_frequency = parent_sorting.get_sampling_frequency() self.set_tmp_folder(parent_sorting.get_tmp_folder()) # Create and store roots with original unit ids and cached spiketrains self._roots = [] for unit_id in self._original_unit_ids: root = Unit(unit_id) root.set_spike_train(parent_sorting.get_unit_spike_train(unit_id)) self._roots.append(root) ''' Copies over properties and spike features from parent_sorting. Only spike features will be preserved with merges and splits, properties cannot be resolved in these cases. ''' self.copy_unit_properties(parent_sorting) self.copy_unit_spike_features(parent_sorting) self.copy_epochs(parent_sorting) self.copy_times(parent_sorting) self.curation_steps = curation_steps self._kwargs = { 'parent_sorting': parent_sorting.make_serialized_dict(), 'curation_steps': self.curation_steps } self.curation_steps = [] if curation_steps is not None: assert isinstance( curation_steps, list ), "previous_curation_steps must be a list of previous curation commands" for i, curation_step in enumerate(curation_steps): command, arguments = curation_step if command == 'exclude_units': assert len( arguments ) == 1, "Length of arguments must be 1 for exclude_units" unit_ids = arguments[0] self.exclude_units(unit_ids=unit_ids) elif command == 'merge_units': assert len( arguments ) == 1, "Length of arguments must be 1 for merge_units" unit_ids = arguments[0] self.merge_units(unit_ids=unit_ids) elif command == 'split_unit': assert len( arguments ) == 2, "Length of arguments must be 2 for split_unit" unit_id = arguments[0] indices = arguments[1] self.split_unit(unit_id=unit_id, indices=indices) else: raise ValueError( "{} is not a valid curation command".format(command))
def __init__(self, recording_file): SortingExtractor.__init__(self) self._recording_file = recording_file self._rf = h5py.File(self._recording_file, mode='r') self._unit_ids = set(self._rf['cluster_id'].value) if 'centres' in self._rf.keys(): self._unit_locs = self._rf[ 'centres'].value # cache for faster access
def __init__(self, firings_file): SortingExtractor.__init__(self) self._firings_path = firings_file self._firings = readmda(self._firings_path) self._times = self._firings[1, :] self._labels = self._firings[2, :] self._unit_ids = np.unique(self._labels).astype(int)
def __init__(self, recording_path): SortingExtractor.__init__(self) self._recording_path = recording_path self._num_units = None self._spike_trains = None self._unit_ids = None self._fs = None self._initialize()
def __init__(self, h5_path): SortingExtractor.__init__(self) self._h5_path = h5_path self._loaded_spike_trains = {} with h5py.File(self._h5_path, 'r') as f: self._unit_ids = np.array(f.get('unit_ids')) self._sampling_frequency = np.array(f.get('sampling_frequency'))[0]
def __init__(self, recording_file, *, experiment_id=0, recording_id=0): assert HAVE_OE, "To use the OpenEphys extractor, install pyopenephys: \n\n pip install pyopenephys\n\n" SortingExtractor.__init__(self) self._recording_file = recording_file self._recording = pyopenephys.File( recording_file).experiments[experiment_id].recordings[recording_id] self._spiketrains = self._recording.spiketrains self._unit_ids = list( [np.unique(st.clusters)[0] for st in self._spiketrains])
def __init__(self, file_path): assert self.installed, self.installation_mesg SortingExtractor.__init__(self) self._file_path = file_path self._filehandle = None self._mapping = None self._version = None self._initialize() self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self, file_path): SortingExtractor.__init__(self) self._recording_path = file_path self._num_units = None self._spike_trains = None self._unit_ids = None self._fs = None self._initialize() self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self, file_path): SortingExtractor.__init__(self) self._file = nix.File.open(file_path, nix.FileMode.ReadOnly) md = self._file.sections if "sampling_frequency" in md: sfreq = md["sampling_frequency"] self._sampling_frequency = sfreq self._load_properties() self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self, recording_path): neo, pq, h5py, yaml = _load_required_modules() SortingExtractor.__init__(self) self._recording_path = recording_path self._num_units = None self._spike_trains = None self._unit_ids = None self._fs = None self._initialize()
def __init__(self, kwik_file_or_folder): assert HAVE_KLSX, "To use the KlustaSortingExtractor install h5py: \n\n pip install h5py\n\n" SortingExtractor.__init__(self) kwik_file_or_folder = Path(kwik_file_or_folder) kwikfile = None klustafolder = None if kwik_file_or_folder.is_file(): assert kwik_file_or_folder.suffix == '.kwik', "Not a '.kwik' file" kwikfile = Path(kwik_file_or_folder).absolute() klustafolder = kwikfile.parent elif kwik_file_or_folder.is_dir(): klustafolder = kwik_file_or_folder kwikfiles = [f for f in kwik_file_or_folder.iterdir() if f.suffix == '.kwik'] if len(kwikfiles) == 1: kwikfile = kwikfiles[0] assert kwikfile is not None, "Could not load '.kwik' file" try: config_file = [f for f in klustafolder.iterdir() if f.suffix == '.prm'][0] config = read_python(str(config_file)) sample_rate = config['traces']['sample_rate'] self._sampling_frequency = sample_rate except Exception as e: print("Could not load sampling frequency info") F = h5py.File(kwikfile) channel_groups = F.get('channel_groups') self._spiketrains = [] self._unit_ids = [] unique_units = [] klusta_units = [] groups = [] unit = 0 for cgroup in channel_groups: group_id = int(cgroup) try: cluster_ids = channel_groups[cgroup]['clusters']['main'] except Exception as e: print('Unable to extract clusters from', kwikfile) continue for cluster_id in channel_groups[cgroup]['clusters']['main']: clusters = np.array(channel_groups[cgroup]['spikes']['clusters']['main']) idx = np.nonzero(clusters == int(cluster_id)) st = np.array(channel_groups[cgroup]['spikes']['time_samples'])[idx] self._spiketrains.append(st) klusta_units.append(int(cluster_id)) unique_units.append(unit) unit += 1 groups.append(group_id) if len(np.unique(klusta_units)) == len(np.unique(unique_units)): self._unit_ids = klusta_units else: print('Klusta units are not unique! Using unique unit ids') self._unit_ids = unique_units for i, u in enumerate(self._unit_ids): self.set_unit_property(u, 'group', groups[i])
def __init__(self, file_path, delimiter=','): SortingExtractor.__init__(self) if os.path.isfile(file_path): self._spike_clusters = sbio.SpikeClusters() self._spike_clusters.fromCSV(file_path, None, delimiter=delimiter) else: raise FileNotFoundError( 'the ground truth file "{}" could not be found'.format( file_path))
def __init__(self, file_path, delimiter=','): assert HAVE_SBEX, self.installation_mesg SortingExtractor.__init__(self) if os.path.isfile(file_path): self._spike_clusters = sbio.SpikeClusters() self._spike_clusters.fromCSV(file_path, None, delimiter=delimiter) else: raise FileNotFoundError('the ground truth file "{}" could not be found'.format(file_path)) self._kwargs = {'file_path': str(Path(file_path).absolute()), 'delimiter': delimiter}
def __init__(self, file_path, *, experiment_id=0, recording_id=0): assert HAVE_OE, "To use the OpenEphys extractor, install pyopenephys: \n\n pip install pyopenephys\n\n" SortingExtractor.__init__(self) self._recording_file = file_path self._recording = pyopenephys.File( file_path).experiments[experiment_id].recordings[recording_id] self._spiketrains = self._recording.spiketrains self._unit_ids = list( [np.unique(st.clusters)[0] for st in self._spiketrains]) self._sampling_frequency = float( self._recording.sample_rate.rescale('Hz').magnitude)
def __init__(self, folder_path, *, experiment_id=0, recording_id=0): assert HAVE_OE, self.installation_mesg SortingExtractor.__init__(self) self._recording_file = folder_path self._recording = pyopenephys.File(folder_path).experiments[experiment_id].recordings[recording_id] self._spiketrains = self._recording.spiketrains self._unit_ids = list([np.unique(st.clusters)[0] for st in self._spiketrains]) self._sampling_frequency = float(self._recording.sample_rate.rescale('Hz').magnitude) self._kwargs = {'folder_path': str(Path(folder_path).absolute()), 'experiment_id': experiment_id, 'recording_id': recording_id}
def __init__(self, firings_file, samplerate): SortingExtractor.__init__(self) self._firings_path = ka.load_file(firings_file) if not self._firings_path: raise Exception('Unable to load firings file: ' + firings_file) self._firings = readmda(self._firings_path) self._sampling_frequency = samplerate self._times = self._firings[1, :] self._labels = self._firings[2, :] self._unit_ids = np.unique(self._labels).astype(int)
def __init__(self, folder_path, sampling_frequency=None, channel_group=None, load_waveforms=False): assert HAVE_EXDIR, "To use the ExdirExtractors run:\n\n pip install exdir\n\n" SortingExtractor.__init__(self) self._exdir_file = folder_path exdir_group = exdir.File(folder_path, plugins=exdir.plugins.quantities) electrophysiology = None sf = copy(sampling_frequency) if 'processing' in exdir_group.keys(): if 'electrophysiology' in exdir_group['processing']: electrophysiology = exdir_group['processing']['electrophysiology'] ephys_attrs = electrophysiology.attrs if 'sample_rate' in ephys_attrs: sf = ephys_attrs['sample_rate'] else: if sf is None: raise Exception("Sampling rate information not found. Please provide it with the 'sampling_frequency' " "argument") else: sf = sf * pq.Hz self._sampling_frequency = float(sf.rescale('Hz').magnitude) if electrophysiology is None: raise Exception("'electrophysiology' group not found!") self._unit_ids = [] current_unit = 1 self._spike_trains = [] for chan_name, channel in electrophysiology.items(): if 'channel' in chan_name: group = int(chan_name.split('_')[-1]) if channel_group is not None: if group != channel_group: continue if load_waveforms: if 'Clustering' in channel.keys() and 'EventWaveform' in channel.keys(): clustering = channel.require_group('Clustering') eventwaveform = channel.require_group('EventWaveform') nums = clustering['nums'].data waveforms = eventwaveform.require_group('waveform_timeseries')['data'].data if 'UnitTimes' in channel.keys(): for unit, unit_times in channel['UnitTimes'].items(): self._unit_ids.append(current_unit) self._spike_trains.append((unit_times['times'].data.rescale('s') * sf).magnitude) attrs = unit_times.attrs for k, v in attrs.items(): self.set_unit_property(current_unit, k, v) if load_waveforms: unit_idxs = np.where(nums == int(unit)) wf = waveforms[unit_idxs] self.set_unit_spike_features(current_unit, 'waveforms', wf) current_unit += 1 self._kwargs = {'folder_path': str(Path(folder_path).absolute()), 'sampling_frequency': sampling_frequency, 'channel_group': channel_group, 'load_waveforms': load_waveforms}
def __init__(self, folder_path): assert HAVE_SCSX, self.installation_mesg SortingExtractor.__init__(self) spykingcircus_folder = Path(folder_path) listfiles = spykingcircus_folder.iterdir() results = None sample_rate = None parent_folder = None result_folder = None for f in listfiles: if f.is_dir(): if any([f_.suffix == '.hdf5' for f_ in f.iterdir()]): parent_folder = spykingcircus_folder result_folder = f if parent_folder is None: parent_folder = spykingcircus_folder.parent for f in parent_folder.iterdir(): if f.is_dir(): if any([f_.suffix == '.hdf5' for f_ in f.iterdir()]): result_folder = spykingcircus_folder assert isinstance(parent_folder, Path) and isinstance( result_folder, Path), "Not a valid spyking circus folder" # load files for f in result_folder.iterdir(): if 'result.hdf5' in str(f): results = f if 'result-merged.hdf5' in str(f): results = f break # load params for f in parent_folder.iterdir(): if f.suffix == '.params': sample_rate = _load_sample_rate(f) if sample_rate is not None: self._sampling_frequency = sample_rate if results is None: raise Exception(spykingcircus_folder, " is not a spyking circus folder") f_results = h5py.File(results, 'r') self._spiketrains = [] self._unit_ids = [] for temp in f_results['spiketimes'].keys(): self._spiketrains.append( np.array(f_results['spiketimes'][temp]).astype('int64')) self._unit_ids.append(int(temp.split('_')[-1])) self._kwargs = {'folder_path': str(Path(folder_path).absolute())}
def __init__(self, file_path, well_name='well000', rec_name='rec0000'): assert self.installed, self.installation_mesg SortingExtractor.__init__(self) self._file_path = file_path self._well_name = well_name self._rec_name = rec_name self._filehandle = None self._mapping = None self._version = None self._initialize() self._sampling_frequency = self._fs self._kwargs = {'file_path': str(Path(file_path).absolute()), 'well_name': well_name, 'rec_name': rec_name}
def __init__(self, tdc_folder, chan_grp=None): assert HAVE_TDC, "must install tridesclous" tdc_folder = Path(tdc_folder) SortingExtractor.__init__(self) self.dataio = tdc.DataIO(str(tdc_folder)) if chan_grp is None: # if chan_grp is not provided, take the first one if unique chan_grps = list(self.dataio.channel_groups.keys()) assert len(chan_grps) == 1, 'There are several in the folder chan_grp, specify it' chan_grp = chan_grps[0] self.chan_grp = chan_grp self.catalogue = self.dataio.load_catalogue(name='initial', chan_grp=chan_grp)
def __init__(self, spykingcircus_folder): assert HAVE_SCSX, "To use the SpykingCircusSortingExtractor install h5py: \n\n pip install h5py\n\n" SortingExtractor.__init__(self) spykingcircus_folder = Path(spykingcircus_folder) listfiles = spykingcircus_folder.iterdir() results = None sample_rate = None parent_folder = None result_folder = None for f in listfiles: if f.is_dir(): if any([f_.suffix == '.hdf5' for f_ in f.iterdir()]): parent_folder = spykingcircus_folder result_folder = f if parent_folder is None: parent_folder = spykingcircus_folder.parent for f in parent_folder.iterdir(): if f.is_dir(): if any([f_.suffix == '.hdf5' for f_ in f.iterdir()]): result_folder = spykingcircus_folder assert isinstance(parent_folder, Path) and isinstance( result_folder, Path), "Not a valid spyking circus folder" # load files for f in result_folder.iterdir(): if 'result.hdf5' in str(f): results = f if 'result-merged.hdf5' in str(f): results = f break # load params for f in parent_folder.iterdir(): if f.suffix == '.params': sample_rate = _load_sample_rate(f) if sample_rate is not None: self._sampling_frequency = sample_rate if results is None: raise Exception(spykingcircus_folder, " is not a spyking circus folder") f_results = h5py.File(results) self._spiketrains = [] self._unit_ids = [] for temp in f_results['spiketimes'].keys(): self._spiketrains.append(f_results['spiketimes'][temp]) self._unit_ids.append(int(temp.split('_')[-1]))