def get_cells(path=None, **kwargs): """Get cells to use during the generation. Parameter: path: none | string (optional) The path to the directory in which to look for the cells. Return: cells: dictionary The cells to get. See also: circusort.io.generate_cells circusort.io.get_cell """ if isinstance(path, (str, unicode)): path = normalize_path(path, **kwargs) if path[-6:] != "/cells": path = os.path.join(path, "cells") if os.path.isdir(path): try: cells = load_cells(path, **kwargs) except OSError: cells = generate_cells(**kwargs) else: cells = generate_cells(**kwargs) else: cells = generate_cells(**kwargs) return cells
def plot(self, output=None, **kwargs): if output is None: raise NotImplementedError() # TODO complete. else: path = normalize_path(output) if os.path.isdir(path): if 'rate' in self.parameters['train']: self.plot_rate(output=path, **kwargs) if 'x' in self.parameters[ 'position'] and 'y' in self.parameters['position']: self.plot_position(output=path, **kwargs) if self.amplitude is not None: self.amplitude.plot(output=path, **kwargs) if self.position is not None: self.position.plot(output=path, **kwargs) self.train.plot(output=path, **kwargs) self.template.plot(output=path, **kwargs) else: raise NotImplementedError() # TODO complete. return
def plot_positions(self, output=None, ax=None, **kwargs): if output is not None and ax is None: plt.ioff() if ax is None: fig = plt.figure() gs = gds.GridSpec(1, 1) ax_ = fig.add_subplot(gs[0]) self._plot_positions(ax_, **kwargs) gs.tight_layout(fig) if output is None: fig.show() else: path = normalize_path(output) if path[-4:] != ".pdf": path = os.path.join(path, "positions.pdf") directory = os.path.dirname(path) if not os.path.isdir(directory): os.makedirs(directory) fig.savefig(path) else: self._plot_positions(ax, **kwargs) return
def plot(self, output=None, ax=None, **kwargs): """Plot data from file. Arguments: output: none | string (optional) The default value is None. ax: none | matplotlib.axes.Axes (optional) The default value is None. kwargs: dict (optional) Additional keyword arguments. See matplotlib.axes.Axes.plot for details. Return: ax: matplotlib.axes.Axes """ if output is not None and ax is None: plt.ioff() if ax is None: fig = plt.figure() gs = gds.GridSpec(1, 1) ax_ = fig.add_subplot(gs[0]) ax = self._plot(ax_, **kwargs) gs.tight_layout(fig) if output is None: fig.show() else: path = normalize_path(output) directory = os.path.dirname(path) if not os.path.isdir(directory): os.makedirs(directory) fig.savefig(path) else: self._plot(ax, **kwargs) return ax
def save(self, path, mode='default', **kwargs): """Save cells to files. Parameters: path: string The path to the directory in which to save the cells. mode: string (optional) The mode to use to save the cells. Either 'default', 'by cells' or 'by components'. The default value is 'default'. """ if mode == 'default' or mode == 'by cells': path = normalize_path(path, **kwargs) cells_directory = os.path.join(path, "cells") self.parameters.save(cells_directory, **kwargs) for k, cell in self.items(): cell_directory = os.path.join(cells_directory, "{}".format(k)) cell.save(cell_directory) # Update private attributes. self._mode = 'default' elif mode == 'by components': raise NotImplementedError() # TODO complete. else: message = "Unknown mode value: {}".format(mode) raise ValueError(message) return
def plot_y_position(self, output=None, ax=None, **kwargs): if output is not None and ax is None: plt.ioff() try: if ax is None: fig = plt.figure() gs = gds.GridSpec(1, 1) ax_ = plt.subplot(gs[0]) self._plot_y_position(ax_, **kwargs) gs.tight_layout(fig) if output is None: plt.show() else: path = normalize_path(output) if path[-4:] != ".pdf": path = os.path.join(path, "parameters_y_position.pdf") directory = os.path.dirname(path) if not os.path.isdir(directory): os.makedirs(directory) plt.savefig(path) else: self._plot_y_position(ax, **kwargs) except TypeError: pass return
def plot(self, output=None, ax=None, set_ax=False, **kwargs): # TODO add docstring. if output is not None and ax is None: plt.ioff() if ax is None: fig = plt.figure() gs = gds.GridSpec(1, 1) ax_ = fig.add_subplot(gs[0]) self._plot(ax_, set_ax=True, **kwargs) gs.tight_layout(fig) if output is None: fig.show() else: path = normalize_path(output) if path[-4:] != ".pdf": path = os.path.join(path, "amplitude.pdf") directory = os.path.dirname(path) if not os.path.isdir(directory): os.makedirs(directory) fig.savefig(path) else: self._plot(ax, set_ax=set_ax, **kwargs) return
def get_parameters(path=None, defaults=None, types=None, default_type='string', **kwargs): """Get parameters from path. Parameter: path: none | string The path to the file from which to load the parameters. The default value is None. defaults: none | dictionary The default values of the parameters. The default value is None. types: none | dictionary The default types of the parameters. The default value is None. Return: parameters: dictionary The loaded parameters. """ if isinstance(path, (str, unicode)): path = normalize_path(path, **kwargs) if os.path.isdir(path): path = os.path.join(path, "parameters.txt") if os.path.isfile(path): try: parameters = load_parameters(path, defaults=defaults, types=types, default_type=default_type) except (IOError, ValueError): parameters = generate_parameters(defaults=defaults, types=types) else: parameters = generate_parameters(defaults=defaults, types=types) else: parameters = generate_parameters(defaults=defaults, types=types) return parameters
def load_template_store(path, probe_file=None): """Load a template store from disk. Parameter: path: string The path to the HDF5 file from which to load the template store. Return: store: circusort.obj.TemplateStore """ path = normalize_path(path) store = TemplateStore(path, probe_file=probe_file, mode='r') return store
def get_configurations(path=None, **kwargs): if isinstance(path, (str, unicode)): path = normalize_path(path, **kwargs) paths = list_configuration_paths(path) if paths: names = list_configuration_names(path) configurations = [get_configuration(path=path) for path in paths] for configuration, name in zip(configurations, names): configuration['general']['name'] = name else: raise NotImplementedError() # TODO generate default configuration. else: raise NotImplementedError() # TODO generate default configuration. return configurations
def load_time_measurements(path, name=None): # TODO add docstring. path = normalize_path(path) if os.path.isdir(path): filename = _get_filename(name) path = os.path.join(path, filename) if not os.path.isfile(path): message = "Time measurements file does not exist: {}".format(path) raise OSError(message) with h5py.File(path, mode='r', swmr=True) as file_: measurements = { dataset_name: file_[dataset_name].value for dataset_name in file_.keys() } return measurements
def save_time_measurements(path, measurements, name=None): # TODO add docstring. path = normalize_path(path) _, extension = os.path.splitext(path) if extension == '': filename = _get_filename(name) path = os.path.join(path, filename) directory = os.path.dirname(path) if not os.path.isdir(directory): os.makedirs(directory) with h5py.File(path, mode='w', swmr=True) as file_: for label in measurements: times = np.array(measurements[label]) file_.create_dataset(name=label, data=times) return
def plot(self, output=None, **kwargs): if output is None: raise NotImplementedError() # TODO complete. else: path = normalize_path(output, **kwargs) cells_directory = os.path.join(path, "cells") parameters = get_cells_parameters(cells_directory) kwargs.update(parameters['general']) try: self.plot_rates(output=cells_directory, **kwargs) except NotImplementedError: pass # TODO remove try ... except ... self.plot_trains(output=cells_directory, **kwargs) # TODO plot amplitudes. self.plot_positions(output=cells_directory, **kwargs) for k, cell in self.items(): cell_directory = os.path.join(cells_directory, "{}".format(k)) cell.plot(output=cell_directory, **kwargs) return
def load_templates(path): """Load templates. Parameter: path: string The path to the location from which to load the templates. Either a path to a directory (which contains multiple HDF5 files) or a HDF5 file. Return: templates: dictionary The dictionary of loaded templates. """ path = normalize_path(path) if os.path.isfile(path): templates = _load_templates_from_file(path) elif os.path.isdir(path): templates = _load_templates_from_directory(path) else: message = "No such template file or directory: {}".format(path) raise OSError(message) return templates
def save(self, path, **kwargs): # Normalize path. path = normalize_path(path, **kwargs) # Complete path (if necessary). if path[-4:] != ".txt": path = os.path.join(path, "parameters.txt") # Make directory (if necessary). directory = os.path.dirname(path) if not os.path.isdir(directory): os.makedirs(directory) # Prepare lines to be saved. lines = [] for section in self.parameters.keys(): line = "[{}]\n".format(section) lines.append(line) for option in self.parameters[section].keys(): if option != 'current_directory' and not self._is_general( section, option): value = self.parameters[section][option] line = "{} = {}\n".format(option, value) lines.append(line) line = "\n" lines.append(line) # Open probe file. file_ = open(path, mode='w') # Write lines to save. file_.writelines(lines) # Close probe file. file_.close() return
def load_cells(path=None, mode='default', **kwargs): """Load cells from the specified path. Parameter: path: none | string (optional) The path to the directory from which to load the cells. The default value is None. mode: string (optional) The mode to use to load the cells. Either 'default' or 'by cells. The default value is 'default'. Return: cells: dictionary Dictionary of loaded cells. """ if mode == 'by elements': template_directory = os.path.join(path, "templates") if not os.path.isdir(template_directory): message = "No such templates directory: {}".format( template_directory) raise OSError(message) template_paths = list_templates(template_directory) train_directory = os.path.join(path, "trains") if not os.path.isdir(train_directory): message = "No such trains directory: {}".format(train_directory) raise OSError(message) train_paths = list_trains(train_directory) position_directory = os.path.join(path, "positions") if not os.path.isdir(position_directory): message = "No such positions directory: {}".format( position_directory) raise OSError(message) position_paths = list_positions(position_directory) string = "Different number of templates and trains between {} and {}" message = string.format(template_directory, train_directory) assert len(template_paths) == len(train_paths), message string = "Different number of templates and positions between {} and {}" message = string.format(template_directory, position_directory) assert len(template_paths) == len(position_paths), message nb_cells = len(template_paths) cells = {} for k in range(0, nb_cells): template = load_template(template_paths[k]) train = load_train(train_paths[k]) position = load_position(position_paths[k]) cell = Cell(template, train, position) cells[k] = cell cells = Cells(cells) elif mode in ['default', 'by cells']: path = normalize_path(path, **kwargs) if path[-6:] != "/cells": path = os.path.join(path, "cells") if not os.path.isdir(path): message = "No such cells directory: {}".format(path) raise OSError(message) parameters = get_cells_parameters(path) kwargs.update(parameters['general']) cell_directories = list_cells(path) cells = { k: get_cell(directory=cell_directory, **kwargs) for k, cell_directory in enumerate(cell_directories) } cells = Cells(cells, parameters=parameters) else: message = "Unknown mode value: {}".format(mode) raise ValueError(message) return cells
def load_spikes(*args, **kwargs): """Load spikes from disk. Arguments: args: list If mode is 'raw' then there are three arguments: times_path: string templates_path: string amplitudes_path: string else if mode is 'hdf5' then there is only one argument: path: string kwargs: dict (optional) nb_cells: none | integer (optional) mode: none | string (optional) t_max: none | float (optional) Return: spikes: circusort.obj.Spikes """ nb_cells = kwargs.pop('nb_cells', None) mode = kwargs.pop('mode', None) t_max = kwargs.pop('t_max', None) if mode is None: if len(args) == 1: mode = 'hdf5' elif len(args) == 3: mode = 'raw' else: string = "load_spikes takes exactly 1 or 3 arguments (in 'raw' or 'hdf5' mode) ({} given)" message = string.format(len(args)) raise TypeError(message) if mode == 'raw': if len(args) != 3: message = "load_spikes takes exactly 3 argument (in 'hdf5' mode) ({} given)".format( len(args)) raise TypeError(message) times_path, templates_path, amplitudes_path = args # Normalize paths. times_path = normalize_path(times_path) if os.path.isdir(times_path): os.path.join(times_path, "spikes_times.raw") if not os.path.isfile(times_path): message = "File does not exist: {}".format(times_path) raise OSError(message) templates_path = normalize_path(templates_path) if os.path.isdir(templates_path): os.path.join(templates_path, "templates.h5") if not os.path.isfile(templates_path): message = "File does not exist: {}".format(templates_path) raise OSError(message) amplitudes_path = normalize_path(amplitudes_path) if os.path.isdir(amplitudes_path): os.path.join(amplitudes_path, "amplitudes.h5") if not os.path.isfile(amplitudes_path): message = "File does not exist: {}".format(amplitudes_path) raise OSError(message) data = { 'times': np.fromfile(times_path, dtype=np.int32), 'templates': np.fromfile(templates_path, dtype=np.int32), 'amplitudes': np.fromfile(amplitudes_path, dtype=np.float32), } elif mode == 'hdf5': if len(args) != 1: message = "load_spikes takes exactly 1 argument (in 'raw' mode) ({} given)".format( len(args)) raise TypeError(message) path, = args # Normalize path. path = normalize_path(path, **kwargs) if os.path.isdir(path): os.path.join(path, "spikes.h5") if not os.path.isfile(path): message = "File does not exist: {}".format(path) raise OSError(message) # Read data from HDF5 file. with h5py.File(path, mode='r', swmr=True) as file_: keys = ['times', 'templates', 'amplitudes'] dtypes = ['int32', 'int32', 'float32'] data = { key: file_[key].value if key in file_ else np.empty(0, dtype=dtype) for key, dtype in zip(keys, dtypes) } else: # Raise error. string = "Unknown mode value: {}" message = string.format(mode) raise ValueError(message) # Instantiate object. spikes = Spikes(nb_cells=nb_cells, t_max=t_max, **data) return spikes