def __init__(self, array_annotations=None, **annotations): # this for py27 str vs py3 str in neo attributes ompatibility annotations = check_annotations(annotations) if 'file_origin' not in annotations: # the str is to make compatible with neo_py27 where attribute # used to be str so raw bytes annotations['file_origin'] = str(self._rawio.source_name()) if array_annotations is None: array_annotations = {} for k, v in array_annotations.items(): array_annotations[k] = np.asarray(v) # clean array annotations that are not 1D # TODO remove this once multi-dimensional array_annotations are possible array_annotations = { k: v for k, v in array_annotations.items() if v.ndim == 1 } # this mock the array annotations to avoid inherits DataObject self.array_annotations = ArrayDict(self.shape[-1]) self.array_annotations.update(array_annotations) BaseNeo.__init__(self, **annotations)
class BaseProxy(BaseNeo): def __init__(self, array_annotations=None, **annotations): # this for py27 str vs py3 str in neo attributes ompatibility annotations = check_annotations(annotations) if 'file_origin' not in annotations: # the str is to make compatible with neo_py27 where attribute # used to be str so raw bytes annotations['file_origin'] = str(self._rawio.source_name()) if array_annotations is None: array_annotations = {} for k, v in array_annotations.items(): array_annotations[k] = np.asarray(v) # clean array annotations that are not 1D # TODO remove this once multi-dimensional array_annotations are possible array_annotations = {k: v for k, v in array_annotations.items() if v.ndim == 1} # this mock the array annotations to avoid inherits DataObject self.array_annotations = ArrayDict(self.shape[-1]) self.array_annotations.update(array_annotations) BaseNeo.__init__(self, **annotations) def load(self, time_slice=None, **kwargs): # should be implemented by subclass raise NotImplementedError def time_slice(self, t_start, t_stop): ''' Load the proxy object within the specified time range. Has the same call signature as AnalogSignal.time_slice, Epoch.time_slice, etc. ''' return self.load(time_slice=(t_start, t_stop))
class BaseProxy(BaseNeo): def __init__(self, array_annotations=None, **annotations): # this for py27 str vs py3 str in neo attributes compatibility annotations = check_annotations(annotations) if 'file_origin' not in annotations: # the str is to make compatible with neo_py27 where attribute # used to be str so raw bytes annotations['file_origin'] = str(self._rawio.source_name()) # this mock the array annotaions to avoid inherits DataObject self.array_annotations = ArrayDict(self.shape[-1]) if array_annotations is not None: self.array_annotations.update(array_annotations) BaseNeo.__init__(self, **annotations) def load(self, time_slice=None, **kwargs): # should be implemented by subclass raise NotImplementedError def time_slice(self, t_start, t_stop): ''' Load the proxy object within the specified time range. Has the same call signature as AnalogSignal.time_slice, Epoch.time_slice, etc. ''' return self.load(time_slice=(t_start, t_stop))
def __array_finalize__(self, obj): ''' This is called every time a new :class:`SpikeTrain` is created. It is the appropriate place to set default values for attributes for :class:`SpikeTrain` constructed by slicing or viewing. User-specified values are only relevant for construction from constructor, and these are set in __new__. Then they are just copied over here. Note that the :attr:`waveforms` attibute is not sliced here. Nor is :attr:`t_start` or :attr:`t_stop` modified. ''' # This calls Quantity.__array_finalize__ which deals with # dimensionality super().__array_finalize__(obj) # Supposedly, during initialization from constructor, obj is supposed # to be None, but this never happens. It must be something to do # with inheritance from Quantity. if obj is None: return # Set all attributes of the new object `self` from the attributes # of `obj`. For instance, when slicing, we want to copy over the # attributes of the original object. self.t_start = getattr(obj, 't_start', None) self.t_stop = getattr(obj, 't_stop', None) self.waveforms = getattr(obj, 'waveforms', None) self.left_sweep = getattr(obj, 'left_sweep', None) self.sampling_rate = getattr(obj, 'sampling_rate', None) self.segment = getattr(obj, 'segment', None) self.unit = getattr(obj, 'unit', None) # The additional arguments self.annotations = getattr(obj, 'annotations', {}) # Add empty array annotations, because they cannot always be copied, # but do not overwrite existing ones from slicing etc. # This ensures the attribute exists if not hasattr(self, 'array_annotations'): self.array_annotations = ArrayDict(self._get_arr_ann_length()) # Note: Array annotations have to be changed when slicing or initializing an object, # copying them over in spite of changed data would result in unexpected behaviour # Globally recommended attributes self.name = getattr(obj, 'name', None) self.file_origin = getattr(obj, 'file_origin', None) self.description = getattr(obj, 'description', None) if hasattr(obj, 'lazy_shape'): self.lazy_shape = obj.lazy_shape
def __init__(self, array_annotations=None, **annotations): # this for py27 str vs py3 str in neo attributes ompatibility annotations = check_annotations(annotations) if 'file_origin' not in annotations: # the str is to make compatible with neo_py27 where attribute # used to be str so raw bytes annotations['file_origin'] = str(self._rawio.source_name()) # this mock the array annotaions to avoid inherits DataObject self.array_annotations = ArrayDict(self.shape[-1]) if array_annotations is not None: self.array_annotations.update(array_annotations) BaseNeo.__init__(self, **annotations)
class BaseProxy(BaseNeo): def __init__(self, array_annotations=None, **annotations): # this for py27 str vs py3 str in neo attributes ompatibility annotations = check_annotations(annotations) if 'file_origin' not in annotations: # the str is to make compatible with neo_py27 where attribute # used to be str so raw bytes annotations['file_origin'] = str(self._rawio.source_name()) # this mock the array annotaions to avoid inherits DataObject self.array_annotations = ArrayDict(self.shape[-1]) if array_annotations is not None: self.array_annotations.update(array_annotations) BaseNeo.__init__(self, **annotations)
def __array_finalize__(self, obj): ''' This is called every time a new signal is created. It is the appropriate place to set default values for attributes for a signal constructed by slicing or viewing. User-specified values are only relevant for construction from constructor, and these are set in __new__ in the child object. Then they are just copied over here. Default values for the specific attributes for subclasses (:class:`AnalogSignal` and :class:`IrregularlySampledSignal`) are set in :meth:`_array_finalize_spec` ''' super(BaseSignal, self).__array_finalize__(obj) self._array_finalize_spec(obj) # The additional arguments self.annotations = getattr(obj, 'annotations', {}) # Add empty array annotations, because they cannot always be copied, # but do not overwrite existing ones from slicing etc. # This ensures the attribute exists if not hasattr(self, 'array_annotations'): self.array_annotations = ArrayDict(self._get_arr_ann_length()) # Globally recommended attributes self.name = getattr(obj, 'name', None) self.file_origin = getattr(obj, 'file_origin', None) self.description = getattr(obj, 'description', None) # Parent objects self.segment = getattr(obj, 'segment', None) self.channel_index = getattr(obj, 'channel_index', None)
def __array_finalize__(self, obj): super(Epoch, self).__array_finalize__(obj) self.annotations = getattr(obj, 'annotations', None) self.name = getattr(obj, 'name', None) self.file_origin = getattr(obj, 'file_origin', None) self.description = getattr(obj, 'description', None) self.segment = getattr(obj, 'segment', None) # Add empty array annotations, because they cannot always be copied, # but do not overwrite existing ones from slicing etc. # This ensures the attribute exists if not hasattr(self, 'array_annotations'): self.array_annotations = ArrayDict(self._get_arr_ann_length())
def __array_finalize__(self, obj): ''' This is called every time a new :class:`SpikeTrain` is created. It is the appropriate place to set default values for attributes for :class:`SpikeTrain` constructed by slicing or viewing. User-specified values are only relevant for construction from constructor, and these are set in __new__. Then they are just copied over here. Note that the :attr:`waveforms` attibute is not sliced here. Nor is :attr:`t_start` or :attr:`t_stop` modified. ''' # This calls Quantity.__array_finalize__ which deals with # dimensionality super(SpikeTrain, self).__array_finalize__(obj) # Supposedly, during initialization from constructor, obj is supposed # to be None, but this never happens. It must be something to do # with inheritance from Quantity. if obj is None: return # Set all attributes of the new object `self` from the attributes # of `obj`. For instance, when slicing, we want to copy over the # attributes of the original object. self.t_start = getattr(obj, 't_start', None) self.t_stop = getattr(obj, 't_stop', None) self.waveforms = getattr(obj, 'waveforms', None) self.left_sweep = getattr(obj, 'left_sweep', None) self.sampling_rate = getattr(obj, 'sampling_rate', None) self.segment = getattr(obj, 'segment', None) self.unit = getattr(obj, 'unit', None) # The additional arguments self.annotations = getattr(obj, 'annotations', {}) # Add empty array annotations, because they cannot always be copied, # but do not overwrite existing ones from slicing etc. # This ensures the attribute exists if not hasattr(self, 'array_annotations'): self.array_annotations = ArrayDict(self._get_arr_ann_length()) # Note: Array annotations have to be changed when slicing or initializing an object, # copying them over in spite of changed data would result in unexpected behaviour # Globally recommended attributes self.name = getattr(obj, 'name', None) self.file_origin = getattr(obj, 'file_origin', None) self.description = getattr(obj, 'description', None) if hasattr(obj, 'lazy_shape'): self.lazy_shape = obj.lazy_shape
class SpikeTrain(DataObject): ''' :class:`SpikeTrain` is a :class:`Quantity` array of spike times. It is an ensemble of action potentials (spikes) emitted by the same unit in a period of time. *Usage*:: >>> from neo.core import SpikeTrain >>> from quantities import s >>> >>> train = SpikeTrain([3, 4, 5]*s, t_stop=10.0) >>> train2 = train[1:3] >>> >>> train.t_start array(0.0) * s >>> train.t_stop array(10.0) * s >>> train <SpikeTrain(array([ 3., 4., 5.]) * s, [0.0 s, 10.0 s])> >>> train2 <SpikeTrain(array([ 4., 5.]) * s, [0.0 s, 10.0 s])> *Required attributes/properties*: :times: (quantity array 1D, numpy array 1D, or list) The times of each spike. :units: (quantity units) Required if :attr:`times` is a list or :class:`~numpy.ndarray`, not if it is a :class:`~quantities.Quantity`. :t_stop: (quantity scalar, numpy scalar, or float) Time at which :class:`SpikeTrain` ended. This will be converted to the same units as :attr:`times`. This argument is required because it specifies the period of time over which spikes could have occurred. Note that :attr:`t_start` is highly recommended for the same reason. Note: If :attr:`times` contains values outside of the range [t_start, t_stop], an Exception is raised. *Recommended attributes/properties*: :name: (str) A label for the dataset. :description: (str) Text description. :file_origin: (str) Filesystem path or URL of the original data file. :t_start: (quantity scalar, numpy scalar, or float) Time at which :class:`SpikeTrain` began. This will be converted to the same units as :attr:`times`. Default: 0.0 seconds. :waveforms: (quantity array 3D (spike, channel, time)) The waveforms of each spike. :sampling_rate: (quantity scalar) Number of samples per unit time for the waveforms. :left_sweep: (quantity array 1D) Time from the beginning of the waveform to the trigger time of the spike. :sort: (bool) If True, the spike train will be sorted by time. *Optional attributes/properties*: :dtype: (numpy dtype or str) Override the dtype of the signal array. :copy: (bool) Whether to copy the times array. True by default. Must be True when you request a change of units or dtype. :array_annotations: (dict) Dict mapping strings to numpy arrays containing annotations \ for all data points Note: Any other additional arguments are assumed to be user-specific metadata and stored in :attr:`annotations`. *Properties available on this object*: :sampling_period: (quantity scalar) Interval between two samples. (1/:attr:`sampling_rate`) :duration: (quantity scalar) Duration over which spikes can occur, read-only. (:attr:`t_stop` - :attr:`t_start`) :spike_duration: (quantity scalar) Duration of a waveform, read-only. (:attr:`waveform`.shape[2] * :attr:`sampling_period`) :right_sweep: (quantity scalar) Time from the trigger times of the spikes to the end of the waveforms, read-only. (:attr:`left_sweep` + :attr:`spike_duration`) :times: (quantity array 1D) Returns the :class:`SpikeTrain` as a quantity array. *Slicing*: :class:`SpikeTrain` objects can be sliced. When this occurs, a new :class:`SpikeTrain` (actually a view) is returned, with the same metadata, except that :attr:`waveforms` is also sliced in the same way (along dimension 0). Note that t_start and t_stop are not changed automatically, although you can still manually change them. ''' _parent_objects = ('Segment',) _parent_attrs = ('segment',) _quantity_attr = 'times' _necessary_attrs = (('times', pq.Quantity, 1), ('t_start', pq.Quantity, 0), ('t_stop', pq.Quantity, 0)) _recommended_attrs = ((('waveforms', pq.Quantity, 3), ('left_sweep', pq.Quantity, 0), ('sampling_rate', pq.Quantity, 0)) + BaseNeo._recommended_attrs) def __new__(cls, times, t_stop, units=None, dtype=None, copy=True, sampling_rate=1.0 * pq.Hz, t_start=0.0 * pq.s, waveforms=None, left_sweep=None, name=None, file_origin=None, description=None, array_annotations=None, **annotations): ''' Constructs a new :clas:`Spiketrain` instance from data. This is called whenever a new :class:`SpikeTrain` is created from the constructor, but not when slicing. ''' if len(times) != 0 and waveforms is not None and len(times) != waveforms.shape[0]: # len(times)!=0 has been used to workaround a bug occuring during neo import raise ValueError("the number of waveforms should be equal to the number of spikes") if dtype is not None and hasattr(times, 'dtype') and times.dtype != dtype: if not copy: raise ValueError("cannot change dtype and return view") # if t_start.dtype or t_stop.dtype != times.dtype != dtype, # _check_time_in_range can have problems, so we set the t_start # and t_stop dtypes to be the same as times before converting them # to dtype below # see ticket #38 if hasattr(t_start, 'dtype') and t_start.dtype != times.dtype: t_start = t_start.astype(times.dtype) if hasattr(t_stop, 'dtype') and t_stop.dtype != times.dtype: t_stop = t_stop.astype(times.dtype) # Make sure units are consistent # also get the dimensionality now since it is much faster to feed # that to Quantity rather than a unit times, dim = normalize_times_array(times, units, dtype, copy) # Construct Quantity from data obj = times.view(cls) # spiketrain times always need to be 1-dimensional if len(obj.shape) > 1: raise ValueError("Spiketrain times array has more than 1 dimension") # if the dtype and units match, just copy the values here instead # of doing the much more expensive creation of a new Quantity # using items() is orders of magnitude faster if (hasattr(t_start, 'dtype') and t_start.dtype == obj.dtype and hasattr(t_start, 'dimensionality') and t_start.dimensionality.items() == dim.items()): obj.t_start = t_start.copy() else: obj.t_start = pq.Quantity(t_start, units=dim, dtype=obj.dtype) if (hasattr(t_stop, 'dtype') and t_stop.dtype == obj.dtype and hasattr(t_stop, 'dimensionality') and t_stop.dimensionality.items() == dim.items()): obj.t_stop = t_stop.copy() else: obj.t_stop = pq.Quantity(t_stop, units=dim, dtype=obj.dtype) # Store attributes obj.waveforms = waveforms obj.left_sweep = left_sweep obj.sampling_rate = sampling_rate # parents obj.segment = None obj.unit = None # Error checking (do earlier?) _check_time_in_range(obj, obj.t_start, obj.t_stop, view=True) return obj def __init__(self, times, t_stop, units=None, dtype=None, copy=True, sampling_rate=1.0 * pq.Hz, t_start=0.0 * pq.s, waveforms=None, left_sweep=None, name=None, file_origin=None, description=None, array_annotations=None, **annotations): ''' Initializes a newly constructed :class:`SpikeTrain` instance. ''' # This method is only called when constructing a new SpikeTrain, # not when slicing or viewing. We use the same call signature # as __new__ for documentation purposes. Anything not in the call # signature is stored in annotations. # Calls parent __init__, which grabs universally recommended # attributes and sets up self.annotations DataObject.__init__(self, name=name, file_origin=file_origin, description=description, array_annotations=array_annotations, **annotations) def _repr_pretty_(self, pp, cycle): super()._repr_pretty_(pp, cycle) def rescale(self, units): ''' Return a copy of the :class:`SpikeTrain` converted to the specified units ''' obj = super().rescale(units) obj.t_start = self.t_start.rescale(units) obj.t_stop = self.t_stop.rescale(units) obj.unit = self.unit return obj def __reduce__(self): ''' Map the __new__ function onto _new_BaseAnalogSignal, so that pickle works ''' import numpy return _new_spiketrain, (self.__class__, numpy.array(self), self.t_stop, self.units, self.dtype, True, self.sampling_rate, self.t_start, self.waveforms, self.left_sweep, self.name, self.file_origin, self.description, self.array_annotations, self.annotations, self.segment, self.unit) def __array_finalize__(self, obj): ''' This is called every time a new :class:`SpikeTrain` is created. It is the appropriate place to set default values for attributes for :class:`SpikeTrain` constructed by slicing or viewing. User-specified values are only relevant for construction from constructor, and these are set in __new__. Then they are just copied over here. Note that the :attr:`waveforms` attibute is not sliced here. Nor is :attr:`t_start` or :attr:`t_stop` modified. ''' # This calls Quantity.__array_finalize__ which deals with # dimensionality super().__array_finalize__(obj) # Supposedly, during initialization from constructor, obj is supposed # to be None, but this never happens. It must be something to do # with inheritance from Quantity. if obj is None: return # Set all attributes of the new object `self` from the attributes # of `obj`. For instance, when slicing, we want to copy over the # attributes of the original object. self.t_start = getattr(obj, 't_start', None) self.t_stop = getattr(obj, 't_stop', None) self.waveforms = getattr(obj, 'waveforms', None) self.left_sweep = getattr(obj, 'left_sweep', None) self.sampling_rate = getattr(obj, 'sampling_rate', None) self.segment = getattr(obj, 'segment', None) self.unit = getattr(obj, 'unit', None) # The additional arguments self.annotations = getattr(obj, 'annotations', {}) # Add empty array annotations, because they cannot always be copied, # but do not overwrite existing ones from slicing etc. # This ensures the attribute exists if not hasattr(self, 'array_annotations'): self.array_annotations = ArrayDict(self._get_arr_ann_length()) # Note: Array annotations have to be changed when slicing or initializing an object, # copying them over in spite of changed data would result in unexpected behaviour # Globally recommended attributes self.name = getattr(obj, 'name', None) self.file_origin = getattr(obj, 'file_origin', None) self.description = getattr(obj, 'description', None) if hasattr(obj, 'lazy_shape'): self.lazy_shape = obj.lazy_shape def __repr__(self): ''' Returns a string representing the :class:`SpikeTrain`. ''' return '<SpikeTrain(%s, [%s, %s])>' % ( super().__repr__(), self.t_start, self.t_stop) def sort(self): ''' Sorts the :class:`SpikeTrain` and its :attr:`waveforms`, if any, by time. ''' # sort the waveforms by the times sort_indices = np.argsort(self) if self.waveforms is not None and self.waveforms.any(): self.waveforms = self.waveforms[sort_indices] self.array_annotate(**deepcopy(self.array_annotations_at_index(sort_indices))) # now sort the times # We have sorted twice, but `self = self[sort_indices]` introduces # a dependency on the slicing functionality of SpikeTrain. super().sort() def __getslice__(self, i, j): ''' Get a slice from :attr:`i` to :attr:`j`. Doesn't get called in Python 3, :meth:`__getitem__` is called instead ''' return self.__getitem__(slice(i, j)) def __add__(self, time): ''' Shifts the time point of all spikes by adding the amount in :attr:`time` (:class:`Quantity`) If `time` is a scalar, this also shifts :attr:`t_start` and :attr:`t_stop`. If `time` is an array, :attr:`t_start` and :attr:`t_stop` are not changed unless some of the new spikes would be outside this range. In this case :attr:`t_start` and :attr:`t_stop` are modified if necessary to ensure they encompass all spikes. It is not possible to add two SpikeTrains (raises ValueError). ''' spikes = self.view(pq.Quantity) check_has_dimensions_time(time) if isinstance(time, SpikeTrain): raise TypeError("Can't add two spike trains") new_times = spikes + time if time.size > 1: t_start = min(self.t_start, np.min(new_times)) t_stop = max(self.t_stop, np.max(new_times)) else: t_start = self.t_start + time t_stop = self.t_stop + time return SpikeTrain(times=new_times, t_stop=t_stop, units=self.units, sampling_rate=self.sampling_rate, t_start=t_start, waveforms=self.waveforms, left_sweep=self.left_sweep, name=self.name, file_origin=self.file_origin, description=self.description, array_annotations=deepcopy(self.array_annotations), **self.annotations) def __sub__(self, time): ''' Shifts the time point of all spikes by subtracting the amount in :attr:`time` (:class:`Quantity`) If `time` is a scalar, this also shifts :attr:`t_start` and :attr:`t_stop`. If `time` is an array, :attr:`t_start` and :attr:`t_stop` are not changed unless some of the new spikes would be outside this range. In this case :attr:`t_start` and :attr:`t_stop` are modified if necessary to ensure they encompass all spikes. In general, it is not possible to subtract two SpikeTrain objects (raises ValueError). However, if `time` is itself a SpikeTrain of the same size as the SpikeTrain, returns a Quantities array (since this is often used in checking whether two spike trains are the same or in calculating the inter-spike interval. ''' spikes = self.view(pq.Quantity) check_has_dimensions_time(time) if isinstance(time, SpikeTrain): if self.size == time.size: return spikes - time else: raise TypeError("Can't subtract spike trains with different sizes") else: new_times = spikes - time if time.size > 1: t_start = min(self.t_start, np.min(new_times)) t_stop = max(self.t_stop, np.max(new_times)) else: t_start = self.t_start - time t_stop = self.t_stop - time return SpikeTrain(times=spikes - time, t_stop=t_stop, units=self.units, sampling_rate=self.sampling_rate, t_start=t_start, waveforms=self.waveforms, left_sweep=self.left_sweep, name=self.name, file_origin=self.file_origin, description=self.description, array_annotations=deepcopy(self.array_annotations), **self.annotations) def __getitem__(self, i): ''' Get the item or slice :attr:`i`. ''' obj = super().__getitem__(i) if hasattr(obj, 'waveforms') and obj.waveforms is not None: obj.waveforms = obj.waveforms.__getitem__(i) try: obj.array_annotate(**deepcopy(self.array_annotations_at_index(i))) except AttributeError: # If Quantity was returned, not SpikeTrain pass return obj def __setitem__(self, i, value): ''' Set the value the item or slice :attr:`i`. ''' if not hasattr(value, "units"): value = pq.Quantity(value, units=self.units) # or should we be strict: raise ValueError( # "Setting a value # requires a quantity")? # check for values outside t_start, t_stop _check_time_in_range(value, self.t_start, self.t_stop) super().__setitem__(i, value) def __setslice__(self, i, j, value): if not hasattr(value, "units"): value = pq.Quantity(value, units=self.units) _check_time_in_range(value, self.t_start, self.t_stop) super().__setslice__(i, j, value) def _copy_data_complement(self, other, deep_copy=False): ''' Copy the metadata from another :class:`SpikeTrain`. Note: Array annotations can not be copied here because length of data can change ''' # Note: Array annotations cannot be copied because length of data can be changed # here which would cause inconsistencies for attr in ("left_sweep", "sampling_rate", "name", "file_origin", "description", "annotations"): attr_value = getattr(other, attr, None) if deep_copy: attr_value = deepcopy(attr_value) setattr(self, attr, attr_value) def duplicate_with_new_data(self, signal, t_start=None, t_stop=None, waveforms=None, deep_copy=True, units=None): ''' Create a new :class:`SpikeTrain` with the same metadata but different data (times, t_start, t_stop) Note: Array annotations can not be copied here because length of data can change ''' # using previous t_start and t_stop if no values are provided if t_start is None: t_start = self.t_start if t_stop is None: t_stop = self.t_stop if waveforms is None: waveforms = self.waveforms if units is None: units = self.units else: units = pq.quantity.validate_dimensionality(units) new_st = self.__class__(signal, t_start=t_start, t_stop=t_stop, waveforms=waveforms, units=units) new_st._copy_data_complement(self, deep_copy=deep_copy) # Note: Array annotations are not copied here, because length of data could change # overwriting t_start and t_stop with new values new_st.t_start = t_start new_st.t_stop = t_stop # consistency check _check_time_in_range(new_st, new_st.t_start, new_st.t_stop, view=False) _check_waveform_dimensions(new_st) return new_st def time_slice(self, t_start, t_stop): ''' Creates a new :class:`SpikeTrain` corresponding to the time slice of the original :class:`SpikeTrain` between (and including) times :attr:`t_start` and :attr:`t_stop`. Either parameter can also be None to use infinite endpoints for the time interval. ''' _t_start = t_start _t_stop = t_stop if t_start is None: _t_start = -np.inf if t_stop is None: _t_stop = np.inf if _t_start > self.t_stop or _t_stop < self.t_start: # the alternative to raising an exception would be to return # a zero-duration spike train set at self.t_stop or self.t_start raise ValueError("A time slice completely outside the " "boundaries of the spike train is not defined.") indices = (self >= _t_start) & (self <= _t_stop) # Time slicing should create a deep copy of the object new_st = deepcopy(self[indices]) new_st.t_start = max(_t_start, self.t_start) new_st.t_stop = min(_t_stop, self.t_stop) if self.waveforms is not None: new_st.waveforms = self.waveforms[indices] return new_st def time_shift(self, t_shift): """ Shifts a :class:`SpikeTrain` to start at a new time. Parameters: ----------- t_shift: Quantity (time) Amount of time by which to shift the :class:`SpikeTrain`. Returns: -------- spiketrain: :class:`SpikeTrain` New instance of a :class:`SpikeTrain` object starting at t_shift later than the original :class:`SpikeTrain` (the original :class:`SpikeTrain` is not modified). """ new_st = self.duplicate_with_new_data( signal=self.times.view(pq.Quantity) + t_shift, t_start=self.t_start + t_shift, t_stop=self.t_stop + t_shift) # Here we can safely copy the array annotations since we know that # the length of the SpikeTrain does not change. new_st.array_annotate(**self.array_annotations) return new_st def merge(self, *others): ''' Merge other :class:`SpikeTrain` objects into this one. The times of the :class:`SpikeTrain` objects combined in one array and sorted. If the attributes of the :class:`SpikeTrain` objects are not compatible, an Exception is raised. ''' for other in others: if isinstance(other, neo.io.proxyobjects.SpikeTrainProxy): raise MergeError("Cannot merge, SpikeTrainProxy objects cannot be merged" "into regular SpikeTrain objects, please load them first.") elif not isinstance(other, SpikeTrain): raise MergeError("Cannot merge, only SpikeTrain" "can be merged into a SpikeTrain.") if self.sampling_rate != other.sampling_rate: raise MergeError("Cannot merge, different sampling rates") if self.t_start != other.t_start: raise MergeError("Cannot merge, different t_start") if self.t_stop != other.t_stop: raise MergeError("Cannot merge, different t_stop") if self.left_sweep != other.left_sweep: raise MergeError("Cannot merge, different left_sweep") if self.segment != other.segment: raise MergeError("Cannot merge these signals as they belong to" " different segments.") all_spiketrains = [self] all_spiketrains.extend([st.rescale(self.units) for st in others]) wfs = [st.waveforms is not None for st in all_spiketrains] if any(wfs) and not all(wfs): raise MergeError("Cannot merge signal with waveform and signal " "without waveform.") stack = np.concatenate([np.asarray(st) for st in all_spiketrains]) sorting = np.argsort(stack) stack = stack[sorting] kwargs = {} kwargs['array_annotations'] = self._merge_array_annotations(others, sorting=sorting) for name in ("name", "description", "file_origin"): attr = getattr(self, name) # check if self is already a merged spiketrain # if it is, get rid of the bracket at the end to append more attributes if attr is not None: if attr.startswith('merge(') and attr.endswith(')'): attr = attr[:-1] for other in others: attr_other = getattr(other, name) # both attributes are None --> nothing to do if attr is None and attr_other is None: continue # one of the attributes is None --> convert to string in order to merge them elif attr is None or attr_other is None: attr = str(attr) attr_other = str(attr_other) # check if the other spiketrain is already a merged spiketrain # if it is, append all of its merged attributes that aren't already in attr if attr_other.startswith('merge(') and attr_other.endswith(')'): for subattr in attr_other[6:-1].split('; '): if subattr not in attr: attr += '; ' + subattr if not attr.startswith('merge('): attr = 'merge(' + attr # if the other attribute is not in the list --> append # if attr doesn't already start with merge add merge( in the beginning elif attr_other not in attr: attr += '; ' + attr_other if not attr.startswith('merge('): attr = 'merge(' + attr # close the bracket of merge(...) if necessary if attr is not None: if attr.startswith('merge('): attr += ')' # write attr into kwargs dict kwargs[name] = attr merged_annotations = merge_annotations(*(st.annotations for st in all_spiketrains)) kwargs.update(merged_annotations) train = SpikeTrain(stack, units=self.units, dtype=self.dtype, copy=False, t_start=self.t_start, t_stop=self.t_stop, sampling_rate=self.sampling_rate, left_sweep=self.left_sweep, **kwargs) if all(wfs): wfs_stack = np.vstack([st.waveforms.rescale(self.waveforms.units) for st in all_spiketrains]) wfs_stack = wfs_stack[sorting] * self.waveforms.units train.waveforms = wfs_stack train.segment = self.segment if train.segment is not None: self.segment.spiketrains.append(train) return train def _merge_array_annotations(self, others, sorting=None): ''' Merges array annotations of multiple different objects. The merge happens in such a way that the result fits the merged data In general this means concatenating the arrays from the objects. If an annotation is not present in one of the objects, it will be omitted. Apart from that the array_annotations need to be sorted according to the sorting of the spikes. :return Merged array_annotations ''' assert sorting is not None, "The order of the merged spikes must be known" merged_array_annotations = {} omitted_keys_self = [] keys = self.array_annotations.keys() for key in keys: try: self_ann = deepcopy(self.array_annotations[key]) other_ann = np.concatenate([deepcopy(other.array_annotations[key]) for other in others]) if isinstance(self_ann, pq.Quantity): other_ann.rescale(self_ann.units) arr_ann = np.concatenate([self_ann, other_ann]) * self_ann.units else: arr_ann = np.concatenate([self_ann, other_ann]) merged_array_annotations[key] = arr_ann[sorting] # Annotation only available in 'self', must be skipped # Ignore annotations present only in one of the SpikeTrains except KeyError: omitted_keys_self.append(key) continue omitted_keys_other = [key for key in np.unique([key for other in others for key in other.array_annotations]) if key not in self.array_annotations] if omitted_keys_self or omitted_keys_other: warnings.warn("The following array annotations were omitted, because they were only " "present in one of the merged objects: {} from the one that was merged " "into and {} from the ones that were merged into it." "".format(omitted_keys_self, omitted_keys_other), UserWarning) return merged_array_annotations @property def times(self): ''' Returns the :class:`SpikeTrain` as a quantity array. ''' return pq.Quantity(self) @property def duration(self): ''' Duration over which spikes can occur, (:attr:`t_stop` - :attr:`t_start`) ''' if self.t_stop is None or self.t_start is None: return None return self.t_stop - self.t_start @property def spike_duration(self): ''' Duration of a waveform. (:attr:`waveform`.shape[2] * :attr:`sampling_period`) ''' if self.waveforms is None or self.sampling_rate is None: return None return self.waveforms.shape[2] / self.sampling_rate @property def sampling_period(self): ''' Interval between two samples. (1/:attr:`sampling_rate`) ''' if self.sampling_rate is None: return None return 1.0 / self.sampling_rate @sampling_period.setter def sampling_period(self, period): ''' Setter for :attr:`sampling_period` ''' if period is None: self.sampling_rate = None else: self.sampling_rate = 1.0 / period @property def right_sweep(self): ''' Time from the trigger times of the spikes to the end of the waveforms. (:attr:`left_sweep` + :attr:`spike_duration`) ''' dur = self.spike_duration if self.left_sweep is None or dur is None: return None return self.left_sweep + dur
class SpikeTrain(DataObject): ''' :class:`SpikeTrain` is a :class:`Quantity` array of spike times. It is an ensemble of action potentials (spikes) emitted by the same unit in a period of time. *Usage*:: >>> from neo.core import SpikeTrain >>> from quantities import s >>> >>> train = SpikeTrain([3, 4, 5]*s, t_stop=10.0) >>> train2 = train[1:3] >>> >>> train.t_start array(0.0) * s >>> train.t_stop array(10.0) * s >>> train <SpikeTrain(array([ 3., 4., 5.]) * s, [0.0 s, 10.0 s])> >>> train2 <SpikeTrain(array([ 4., 5.]) * s, [0.0 s, 10.0 s])> *Required attributes/properties*: :times: (quantity array 1D, numpy array 1D, or list) The times of each spike. :units: (quantity units) Required if :attr:`times` is a list or :class:`~numpy.ndarray`, not if it is a :class:`~quantites.Quantity`. :t_stop: (quantity scalar, numpy scalar, or float) Time at which :class:`SpikeTrain` ended. This will be converted to the same units as :attr:`times`. This argument is required because it specifies the period of time over which spikes could have occurred. Note that :attr:`t_start` is highly recommended for the same reason. Note: If :attr:`times` contains values outside of the range [t_start, t_stop], an Exception is raised. *Recommended attributes/properties*: :name: (str) A label for the dataset. :description: (str) Text description. :file_origin: (str) Filesystem path or URL of the original data file. :t_start: (quantity scalar, numpy scalar, or float) Time at which :class:`SpikeTrain` began. This will be converted to the same units as :attr:`times`. Default: 0.0 seconds. :waveforms: (quantity array 3D (spike, channel_index, time)) The waveforms of each spike. :sampling_rate: (quantity scalar) Number of samples per unit time for the waveforms. :left_sweep: (quantity array 1D) Time from the beginning of the waveform to the trigger time of the spike. :sort: (bool) If True, the spike train will be sorted by time. *Optional attributes/properties*: :dtype: (numpy dtype or str) Override the dtype of the signal array. :copy: (bool) Whether to copy the times array. True by default. Must be True when you request a change of units or dtype. :array_annotations: (dict) Dict mapping strings to numpy arrays containing annotations \ for all data points Note: Any other additional arguments are assumed to be user-specific metadata and stored in :attr:`annotations`. *Properties available on this object*: :sampling_period: (quantity scalar) Interval between two samples. (1/:attr:`sampling_rate`) :duration: (quantity scalar) Duration over which spikes can occur, read-only. (:attr:`t_stop` - :attr:`t_start`) :spike_duration: (quantity scalar) Duration of a waveform, read-only. (:attr:`waveform`.shape[2] * :attr:`sampling_period`) :right_sweep: (quantity scalar) Time from the trigger times of the spikes to the end of the waveforms, read-only. (:attr:`left_sweep` + :attr:`spike_duration`) :times: (quantity array 1D) Returns the :class:`SpikeTrain` as a quantity array. *Slicing*: :class:`SpikeTrain` objects can be sliced. When this occurs, a new :class:`SpikeTrain` (actually a view) is returned, with the same metadata, except that :attr:`waveforms` is also sliced in the same way (along dimension 0). Note that t_start and t_stop are not changed automatically, although you can still manually change them. ''' _single_parent_objects = ('Segment', 'Unit') _quantity_attr = 'times' _necessary_attrs = (('times', pq.Quantity, 1), ('t_start', pq.Quantity, 0), ('t_stop', pq.Quantity, 0)) _recommended_attrs = ((('waveforms', pq.Quantity, 3), ('left_sweep', pq.Quantity, 0), ('sampling_rate', pq.Quantity, 0)) + BaseNeo._recommended_attrs) def __new__(cls, times, t_stop, units=None, dtype=None, copy=True, sampling_rate=1.0 * pq.Hz, t_start=0.0 * pq.s, waveforms=None, left_sweep=None, name=None, file_origin=None, description=None, array_annotations=None, **annotations): ''' Constructs a new :clas:`Spiketrain` instance from data. This is called whenever a new :class:`SpikeTrain` is created from the constructor, but not when slicing. ''' if len(times) != 0 and waveforms is not None and len(times) != waveforms.shape[0]: # len(times)!=0 has been used to workaround a bug occuring during neo import raise ValueError("the number of waveforms should be equal to the number of spikes") # Make sure units are consistent # also get the dimensionality now since it is much faster to feed # that to Quantity rather than a unit if units is None: # No keyword units, so get from `times` try: dim = times.units.dimensionality except AttributeError: raise ValueError('you must specify units') else: if hasattr(units, 'dimensionality'): dim = units.dimensionality else: dim = pq.quantity.validate_dimensionality(units) if hasattr(times, 'dimensionality'): if times.dimensionality.items() == dim.items(): units = None # units will be taken from times, avoids copying else: if not copy: raise ValueError("cannot rescale and return view") else: # this is needed because of a bug in python-quantities # see issue # 65 in python-quantities github # remove this if it is fixed times = times.rescale(dim) if dtype is None: if not hasattr(times, 'dtype'): dtype = np.float elif hasattr(times, 'dtype') and times.dtype != dtype: if not copy: raise ValueError("cannot change dtype and return view") # if t_start.dtype or t_stop.dtype != times.dtype != dtype, # _check_time_in_range can have problems, so we set the t_start # and t_stop dtypes to be the same as times before converting them # to dtype below # see ticket #38 if hasattr(t_start, 'dtype') and t_start.dtype != times.dtype: t_start = t_start.astype(times.dtype) if hasattr(t_stop, 'dtype') and t_stop.dtype != times.dtype: t_stop = t_stop.astype(times.dtype) # check to make sure the units are time # this approach is orders of magnitude faster than comparing the # reference dimensionality if (len(dim) != 1 or list(dim.values())[0] != 1 or not isinstance(list(dim.keys())[0], pq.UnitTime)): ValueError("Unit has dimensions %s, not [time]" % dim.simplified) # Construct Quantity from data obj = pq.Quantity(times, units=units, dtype=dtype, copy=copy).view(cls) # if the dtype and units match, just copy the values here instead # of doing the much more expensive creation of a new Quantity # using items() is orders of magnitude faster if (hasattr(t_start, 'dtype') and t_start.dtype == obj.dtype and hasattr(t_start, 'dimensionality') and t_start.dimensionality.items() == dim.items()): obj.t_start = t_start.copy() else: obj.t_start = pq.Quantity(t_start, units=dim, dtype=obj.dtype) if (hasattr(t_stop, 'dtype') and t_stop.dtype == obj.dtype and hasattr(t_stop, 'dimensionality') and t_stop.dimensionality.items() == dim.items()): obj.t_stop = t_stop.copy() else: obj.t_stop = pq.Quantity(t_stop, units=dim, dtype=obj.dtype) # Store attributes obj.waveforms = waveforms obj.left_sweep = left_sweep obj.sampling_rate = sampling_rate # parents obj.segment = None obj.unit = None # Error checking (do earlier?) _check_time_in_range(obj, obj.t_start, obj.t_stop, view=True) return obj def __init__(self, times, t_stop, units=None, dtype=np.float, copy=True, sampling_rate=1.0 * pq.Hz, t_start=0.0 * pq.s, waveforms=None, left_sweep=None, name=None, file_origin=None, description=None, array_annotations=None, **annotations): ''' Initializes a newly constructed :class:`SpikeTrain` instance. ''' # This method is only called when constructing a new SpikeTrain, # not when slicing or viewing. We use the same call signature # as __new__ for documentation purposes. Anything not in the call # signature is stored in annotations. # Calls parent __init__, which grabs universally recommended # attributes and sets up self.annotations DataObject.__init__(self, name=name, file_origin=file_origin, description=description, array_annotations=array_annotations, **annotations) def _repr_pretty_(self, pp, cycle): super(SpikeTrain, self)._repr_pretty_(pp, cycle) def rescale(self, units): ''' Return a copy of the :class:`SpikeTrain` converted to the specified units ''' obj = super(SpikeTrain, self).rescale(units) obj.t_start = self.t_start.rescale(units) obj.t_stop = self.t_stop.rescale(units) obj.unit = self.unit return obj def __reduce__(self): ''' Map the __new__ function onto _new_BaseAnalogSignal, so that pickle works ''' import numpy return _new_spiketrain, (self.__class__, numpy.array(self), self.t_stop, self.units, self.dtype, True, self.sampling_rate, self.t_start, self.waveforms, self.left_sweep, self.name, self.file_origin, self.description, self.array_annotations, self.annotations, self.segment, self.unit) def __array_finalize__(self, obj): ''' This is called every time a new :class:`SpikeTrain` is created. It is the appropriate place to set default values for attributes for :class:`SpikeTrain` constructed by slicing or viewing. User-specified values are only relevant for construction from constructor, and these are set in __new__. Then they are just copied over here. Note that the :attr:`waveforms` attibute is not sliced here. Nor is :attr:`t_start` or :attr:`t_stop` modified. ''' # This calls Quantity.__array_finalize__ which deals with # dimensionality super(SpikeTrain, self).__array_finalize__(obj) # Supposedly, during initialization from constructor, obj is supposed # to be None, but this never happens. It must be something to do # with inheritance from Quantity. if obj is None: return # Set all attributes of the new object `self` from the attributes # of `obj`. For instance, when slicing, we want to copy over the # attributes of the original object. self.t_start = getattr(obj, 't_start', None) self.t_stop = getattr(obj, 't_stop', None) self.waveforms = getattr(obj, 'waveforms', None) self.left_sweep = getattr(obj, 'left_sweep', None) self.sampling_rate = getattr(obj, 'sampling_rate', None) self.segment = getattr(obj, 'segment', None) self.unit = getattr(obj, 'unit', None) # The additional arguments self.annotations = getattr(obj, 'annotations', {}) # Add empty array annotations, because they cannot always be copied, # but do not overwrite existing ones from slicing etc. # This ensures the attribute exists if not hasattr(self, 'array_annotations'): self.array_annotations = ArrayDict(self._get_arr_ann_length()) # Note: Array annotations have to be changed when slicing or initializing an object, # copying them over in spite of changed data would result in unexpected behaviour # Globally recommended attributes self.name = getattr(obj, 'name', None) self.file_origin = getattr(obj, 'file_origin', None) self.description = getattr(obj, 'description', None) if hasattr(obj, 'lazy_shape'): self.lazy_shape = obj.lazy_shape def __deepcopy__(self, memo): cls = self.__class__ new_st = cls(np.array(self), self.t_stop, units=self.units, dtype=self.dtype, copy=True, sampling_rate=self.sampling_rate, t_start=self.t_start, waveforms=self.waveforms, left_sweep=self.left_sweep, name=self.name, file_origin=self.file_origin, description=self.description) new_st.__dict__.update(self.__dict__) memo[id(self)] = new_st for k, v in self.__dict__.items(): try: setattr(new_st, k, copy.deepcopy(v, memo)) except TypeError: setattr(new_st, k, v) return new_st def __repr__(self): ''' Returns a string representing the :class:`SpikeTrain`. ''' return '<SpikeTrain(%s, [%s, %s])>' % ( super(SpikeTrain, self).__repr__(), self.t_start, self.t_stop) def sort(self): ''' Sorts the :class:`SpikeTrain` and its :attr:`waveforms`, if any, by time. ''' # sort the waveforms by the times sort_indices = np.argsort(self) if self.waveforms is not None and self.waveforms.any(): self.waveforms = self.waveforms[sort_indices] self.array_annotate(**copy.deepcopy(self.array_annotations_at_index(sort_indices))) # now sort the times # We have sorted twice, but `self = self[sort_indices]` introduces # a dependency on the slicing functionality of SpikeTrain. super(SpikeTrain, self).sort() def __getslice__(self, i, j): ''' Get a slice from :attr:`i` to :attr:`j`. Doesn't get called in Python 3, :meth:`__getitem__` is called instead ''' return self.__getitem__(slice(i, j)) def __add__(self, time): ''' Shifts the time point of all spikes by adding the amount in :attr:`time` (:class:`Quantity`) If `time` is a scalar, this also shifts :attr:`t_start` and :attr:`t_stop`. If `time` is an array, :attr:`t_start` and :attr:`t_stop` are not changed unless some of the new spikes would be outside this range. In this case :attr:`t_start` and :attr:`t_stop` are modified if necessary to ensure they encompass all spikes. It is not possible to add two SpikeTrains (raises ValueError). ''' spikes = self.view(pq.Quantity) check_has_dimensions_time(time) if isinstance(time, SpikeTrain): raise TypeError("Can't add two spike trains") new_times = spikes + time if time.size > 1: t_start = min(self.t_start, np.min(new_times)) t_stop = max(self.t_stop, np.max(new_times)) else: t_start = self.t_start + time t_stop = self.t_stop + time return SpikeTrain(times=new_times, t_stop=t_stop, units=self.units, sampling_rate=self.sampling_rate, t_start=t_start, waveforms=self.waveforms, left_sweep=self.left_sweep, name=self.name, file_origin=self.file_origin, description=self.description, array_annotations=copy.deepcopy(self.array_annotations), **self.annotations) def __sub__(self, time): ''' Shifts the time point of all spikes by subtracting the amount in :attr:`time` (:class:`Quantity`) If `time` is a scalar, this also shifts :attr:`t_start` and :attr:`t_stop`. If `time` is an array, :attr:`t_start` and :attr:`t_stop` are not changed unless some of the new spikes would be outside this range. In this case :attr:`t_start` and :attr:`t_stop` are modified if necessary to ensure they encompass all spikes. In general, it is not possible to subtract two SpikeTrain objects (raises ValueError). However, if `time` is itself a SpikeTrain of the same size as the SpikeTrain, returns a Quantities array (since this is often used in checking whether two spike trains are the same or in calculating the inter-spike interval. ''' spikes = self.view(pq.Quantity) check_has_dimensions_time(time) if isinstance(time, SpikeTrain): if self.size == time.size: return spikes - time else: raise TypeError("Can't subtract spike trains with different sizes") else: new_times = spikes - time if time.size > 1: t_start = min(self.t_start, np.min(new_times)) t_stop = max(self.t_stop, np.max(new_times)) else: t_start = self.t_start - time t_stop = self.t_stop - time return SpikeTrain(times=spikes - time, t_stop=t_stop, units=self.units, sampling_rate=self.sampling_rate, t_start=t_start, waveforms=self.waveforms, left_sweep=self.left_sweep, name=self.name, file_origin=self.file_origin, description=self.description, array_annotations=copy.deepcopy(self.array_annotations), **self.annotations) def __getitem__(self, i): ''' Get the item or slice :attr:`i`. ''' obj = super(SpikeTrain, self).__getitem__(i) if hasattr(obj, 'waveforms') and obj.waveforms is not None: obj.waveforms = obj.waveforms.__getitem__(i) try: obj.array_annotate(**copy.deepcopy(self.array_annotations_at_index(i))) except AttributeError: # If Quantity was returned, not SpikeTrain pass return obj def __setitem__(self, i, value): ''' Set the value the item or slice :attr:`i`. ''' if not hasattr(value, "units"): value = pq.Quantity(value, units=self.units) # or should we be strict: raise ValueError( # "Setting a value # requires a quantity")? # check for values outside t_start, t_stop _check_time_in_range(value, self.t_start, self.t_stop) super(SpikeTrain, self).__setitem__(i, value) def __setslice__(self, i, j, value): if not hasattr(value, "units"): value = pq.Quantity(value, units=self.units) _check_time_in_range(value, self.t_start, self.t_stop) super(SpikeTrain, self).__setslice__(i, j, value) def _copy_data_complement(self, other, deep_copy=False): ''' Copy the metadata from another :class:`SpikeTrain`. Note: Array annotations can not be copied here because length of data can change ''' # Note: Array annotations cannot be copied because length of data can be changed # here which would cause inconsistencies for attr in ("left_sweep", "sampling_rate", "name", "file_origin", "description", "annotations"): attr_value = getattr(other, attr, None) if deep_copy: attr_value = copy.deepcopy(attr_value) setattr(self, attr, attr_value) def duplicate_with_new_data(self, signal, t_start=None, t_stop=None, waveforms=None, deep_copy=True, units=None): ''' Create a new :class:`SpikeTrain` with the same metadata but different data (times, t_start, t_stop) Note: Array annotations can not be copied here because length of data can change ''' # using previous t_start and t_stop if no values are provided if t_start is None: t_start = self.t_start if t_stop is None: t_stop = self.t_stop if waveforms is None: waveforms = self.waveforms if units is None: units = self.units else: units = pq.quantity.validate_dimensionality(units) new_st = self.__class__(signal, t_start=t_start, t_stop=t_stop, waveforms=waveforms, units=units) new_st._copy_data_complement(self, deep_copy=deep_copy) # Note: Array annotations are not copied here, because length of data could change # overwriting t_start and t_stop with new values new_st.t_start = t_start new_st.t_stop = t_stop # consistency check _check_time_in_range(new_st, new_st.t_start, new_st.t_stop, view=False) _check_waveform_dimensions(new_st) return new_st def time_slice(self, t_start, t_stop): ''' Creates a new :class:`SpikeTrain` corresponding to the time slice of the original :class:`SpikeTrain` between (and including) times :attr:`t_start` and :attr:`t_stop`. Either parameter can also be None to use infinite endpoints for the time interval. ''' _t_start = t_start _t_stop = t_stop if t_start is None: _t_start = -np.inf if t_stop is None: _t_stop = np.inf indices = (self >= _t_start) & (self <= _t_stop) new_st = self[indices] new_st.t_start = max(_t_start, self.t_start) new_st.t_stop = min(_t_stop, self.t_stop) if self.waveforms is not None: new_st.waveforms = self.waveforms[indices] return new_st def merge(self, other): ''' Merge another :class:`SpikeTrain` into this one. The times of the :class:`SpikeTrain` objects combined in one array and sorted. If the attributes of the two :class:`SpikeTrain` are not compatible, an Exception is raised. ''' if self.sampling_rate != other.sampling_rate: raise MergeError("Cannot merge, different sampling rates") if self.t_start != other.t_start: raise MergeError("Cannot merge, different t_start") if self.t_stop != other.t_stop: raise MemoryError("Cannot merge, different t_stop") if self.left_sweep != other.left_sweep: raise MemoryError("Cannot merge, different left_sweep") if self.segment != other.segment: raise MergeError("Cannot merge these two signals as they belong to" " different segments.") if hasattr(self, "lazy_shape"): if hasattr(other, "lazy_shape"): merged_lazy_shape = (self.lazy_shape[0] + other.lazy_shape[0]) else: raise MergeError("Cannot merge a lazy object with a real" " object.") if other.units != self.units: other = other.rescale(self.units) wfs = [self.waveforms is not None, other.waveforms is not None] if any(wfs) and not all(wfs): raise MergeError("Cannot merge signal with waveform and signal " "without waveform.") stack = np.concatenate((np.asarray(self), np.asarray(other))) sorting = np.argsort(stack) stack = stack[sorting] kwargs = {} kwargs['array_annotations'] = self._merge_array_annotations(other, sorting=sorting) for name in ("name", "description", "file_origin"): attr_self = getattr(self, name) attr_other = getattr(other, name) if attr_self == attr_other: kwargs[name] = attr_self else: kwargs[name] = "merge(%s, %s)" % (attr_self, attr_other) merged_annotations = merge_annotations(self.annotations, other.annotations) kwargs.update(merged_annotations) train = SpikeTrain(stack, units=self.units, dtype=self.dtype, copy=False, t_start=self.t_start, t_stop=self.t_stop, sampling_rate=self.sampling_rate, left_sweep=self.left_sweep, **kwargs) if all(wfs): wfs_stack = np.vstack((self.waveforms, other.waveforms)) wfs_stack = wfs_stack[sorting] train.waveforms = wfs_stack train.segment = self.segment if train.segment is not None: self.segment.spiketrains.append(train) if hasattr(self, "lazy_shape"): train.lazy_shape = merged_lazy_shape return train def _merge_array_annotations(self, other, sorting=None): ''' Merges array annotations of 2 different objects. The merge happens in such a way that the result fits the merged data In general this means concatenating the arrays from the 2 objects. If an annotation is only present in one of the objects, it will be omitted. Apart from that the array_annotations need to be sorted according to the sorting of the spikes. :return Merged array_annotations ''' assert sorting is not None, "The order of the merged spikes must be known" merged_array_annotations = {} omitted_keys_self = [] keys = self.array_annotations.keys() for key in keys: try: self_ann = copy.deepcopy(self.array_annotations[key]) other_ann = copy.deepcopy(other.array_annotations[key]) if isinstance(self_ann, pq.Quantity): other_ann.rescale(self_ann.units) arr_ann = np.concatenate([self_ann, other_ann]) * self_ann.units else: arr_ann = np.concatenate([self_ann, other_ann]) merged_array_annotations[key] = arr_ann[sorting] # Annotation only available in 'self', must be skipped # Ignore annotations present only in one of the SpikeTrains except KeyError: omitted_keys_self.append(key) continue omitted_keys_other = [key for key in other.array_annotations if key not in self.array_annotations] if omitted_keys_self or omitted_keys_other: warnings.warn("The following array annotations were omitted, because they were only " "present in one of the merged objects: {} from the one that was merged " "into and {} from the one that was merged into the other" "".format(omitted_keys_self, omitted_keys_other), UserWarning) return merged_array_annotations @property def times(self): ''' Returns the :class:`SpikeTrain` as a quantity array. ''' return pq.Quantity(self) @property def duration(self): ''' Duration over which spikes can occur, (:attr:`t_stop` - :attr:`t_start`) ''' if self.t_stop is None or self.t_start is None: return None return self.t_stop - self.t_start @property def spike_duration(self): ''' Duration of a waveform. (:attr:`waveform`.shape[2] * :attr:`sampling_period`) ''' if self.waveforms is None or self.sampling_rate is None: return None return self.waveforms.shape[2] / self.sampling_rate @property def sampling_period(self): ''' Interval between two samples. (1/:attr:`sampling_rate`) ''' if self.sampling_rate is None: return None return 1.0 / self.sampling_rate @sampling_period.setter def sampling_period(self, period): ''' Setter for :attr:`sampling_period` ''' if period is None: self.sampling_rate = None else: self.sampling_rate = 1.0 / period @property def right_sweep(self): ''' Time from the trigger times of the spikes to the end of the waveforms. (:attr:`left_sweep` + :attr:`spike_duration`) ''' dur = self.spike_duration if self.left_sweep is None or dur is None: return None return self.left_sweep + dur