Merge branch 'main' into fix_ryan_error_lfp

Author: alejoe91

doc/how_to/combine_recordings.rst

@@ -4,7 +4,7 @@ Combine recordings in SpikeInterface
 In this tutorial we will walk through combining multiple recording objects. Sometimes this occurs due to hardware
 settings (e.g. Intan software has a default setting of new files every 1 minute) or the experimenter decides to
 split their recording into multiple files for different experimental conditions. If the probe has not been moved,
-however, then during sorting it would likely make sense to combine these individual reocrding objects into one
+however, then during sorting it would likely make sense to combine these individual recording objects into one
 recording object.
 
 **Why Combine?**

src/spikeinterface/core/baserecording.py

@@ -541,13 +541,14 @@ def shift_times(self, shift: int | float, segment_index: int | None = None) -> N
         else:
             segments_to_shift = (segment_index,)
 
-        for idx in segments_to_shift:
-            rs = self._recording_segments[idx]
+        for segment_index in segments_to_shift:
+            rs = self._recording_segments[segment_index]
 
-            if self.has_time_vector(segment_index=idx):
+            if self.has_time_vector(segment_index=segment_index):
                 rs.time_vector += shift
             else:
-                rs.t_start += shift
+                new_start_time = 0 + shift if rs.t_start is None else rs.t_start + shift
+                rs.t_start = new_start_time
 
     def sample_index_to_time(self, sample_ind, segment_index=None):
         """
@@ -749,9 +750,9 @@ def frame_slice(self, start_frame: int | None, end_frame: int | None) -> BaseRec
         Parameters
         ----------
         start_frame : int, optional
-            The start frame, if not provided it is set to 0
+            Start frame index. If None, defaults to the beginning of the recording (frame 0).
         end_frame : int, optional
-            The end frame, it not provided it is set to the total number of samples
+            End frame index. If None, defaults to the last frame of the recording.
 
         Returns
         -------
@@ -771,20 +772,46 @@ def time_slice(self, start_time: float | None, end_time: float | None) -> BaseRe
         Parameters
         ----------
         start_time : float, optional
-            The start time in seconds. If not provided it is set to 0.
+            Start time in seconds. If None, defaults to the beginning of the recording.
         end_time : float, optional
-            The end time in seconds. If not provided it is set to the total duration.
+            End time in seconds. If None, defaults to the end of the recording.
 
         Returns
         -------
         BaseRecording
             A new recording object with only samples between start_time and end_time
         """
+        num_segments = self.get_num_segments()
+        assert (
+            num_segments == 1
+        ), f"Time slicing is only supported for single segment recordings. Found {num_segments} segments."
+
+        t_start = self.get_start_time()
+        t_end = self.get_end_time()
+
+        if start_time is not None:
+            t_start = self.get_start_time()
+            t_start_too_early = start_time < t_start
+            if t_start_too_early:
+                raise ValueError(f"start_time {start_time} is before the start time {t_start} of the recording.")
+            t_start_too_late = start_time > t_end
+            if t_start_too_late:
+                raise ValueError(f"start_time {start_time} is after the end time {t_end} of the recording.")
+            start_frame = self.time_to_sample_index(start_time)
+        else:
+            start_frame = None
 
-        assert self.get_num_segments() == 1, "Time slicing is only supported for single segment recordings."
+        if end_time is not None:
+            t_end_too_early = end_time < t_start
+            if t_end_too_early:
+                raise ValueError(f"end_time {end_time} is before the start time {t_start} of the recording.")
 
-        start_frame = self.time_to_sample_index(start_time) if start_time else None
-        end_frame = self.time_to_sample_index(end_time) if end_time else None
+            t_end_too_late = end_time > t_end
+            if t_end_too_late:
+                raise ValueError(f"end_time {end_time} is after the end time {t_end} of the recording.")
+            end_frame = self.time_to_sample_index(end_time)
+        else:
+            end_frame = None
 
         return self.frame_slice(start_frame=start_frame, end_frame=end_frame)
 

src/spikeinterface/core/generate.py

@@ -33,7 +33,7 @@ def generate_recording(
     set_probe: bool | None = True,
     ndim: int | None = 2,
     seed: int | None = None,
-) -> NumpySorting:
+) -> BaseRecording:
     """
     Generate a lazy recording object.
     Useful for testing API and algos.

src/spikeinterface/core/tests/test_baserecording.py

@@ -412,6 +412,27 @@ def test_time_slice():
     assert np.allclose(sliced_recording_times.get_traces(), sliced_recording_frames.get_traces())
 
 
+def test_out_of_range_time_slice():
+    recording = generate_recording(durations=[0.100])  # duration = 0.1 s
+    recording.shift_times(1.0)  # shifts start time to 1.0 s, end time to 1.1 s
+
+    # start_time before recording
+    with pytest.raises(ValueError, match="start_time .* is before the start time"):
+        recording.time_slice(start_time=0, end_time=None)
+
+    # end_time before start of recording
+    with pytest.raises(ValueError, match="end_time .* is before the start time"):
+        recording.time_slice(start_time=None, end_time=0.5)
+
+    # start_time after end of recording
+    with pytest.raises(ValueError, match="start_time .* is after the end time"):
+        recording.time_slice(start_time=2.0, end_time=None)
+
+    # end_time after end of recording
+    with pytest.raises(ValueError, match="end_time .* is after the end time"):
+        recording.time_slice(start_time=None, end_time=2.0)
+
+
 def test_time_slice_with_time_vector():
 
     # Case with time vector

src/spikeinterface/core/tests/test_time_handling.py

@@ -435,3 +435,12 @@ def _get_sorting_with_recording_attached(self, recording_for_durations, recordin
         assert sorting.has_recording()
 
         return sorting
+
+
+def test_shift_times_with_None_as_t_start():
+    """Ensures we can shift times even when t_stat is None which is interpeted as zero"""
+    recording = generate_recording(num_channels=4, durations=[10])
+
+    assert recording._recording_segments[0].t_start is None
+    recording.shift_times(shift=1.0)  # Shift by one seconds should not generate an error
+    assert recording.get_start_time() == 1.0

src/spikeinterface/extractors/nwbextractors.py

@@ -759,10 +759,13 @@ def _fetch_recording_segment_info_backend(self, file, cache, load_time_vector, s
         if "starting_time" in electrical_series.keys():
             t_start = electrical_series["starting_time"][()]
             sampling_frequency = electrical_series["starting_time"].attrs["rate"]
+            timestamps = None
         elif "timestamps" in electrical_series.keys():
             timestamps = electrical_series["timestamps"][:]
             t_start = timestamps[0]
             sampling_frequency = 1.0 / np.median(np.diff(timestamps[:samples_for_rate_estimation]))
+        else:
+            raise ValueError("TimeSeries must have either starting_time or timestamps")
 
         if load_time_vector and timestamps is not None:
             times_kwargs = dict(time_vector=electrical_series["timestamps"])
@@ -1572,6 +1575,8 @@ def _fetch_recording_segment_info(self, file, cache, load_time_vector, samples_f
             timestamps = timeseries.timestamps
             sampling_frequency = 1.0 / np.median(np.diff(timestamps[:samples_for_rate_estimation]))
             t_start = timestamps[0]
+        else:
+            raise ValueError("TimeSeries must have either starting_time or timestamps")
 
         if load_time_vector and timestamps is not None:
             times_kwargs = dict(time_vector=timestamps)

src/spikeinterface/postprocessing/spike_amplitudes.py

@@ -17,38 +17,19 @@ class ComputeSpikeAmplitudes(AnalyzerExtension):
     Computes the spike amplitudes.
 
     Needs "templates" to be computed first.
-    Localize spikes in 2D or 3D with several methods given the template.
+    Computes spike amplitudes from the template's peak channel for every spike.
 
     Parameters
     ----------
     sorting_analyzer : SortingAnalyzer
         A SortingAnalyzer object
-    ms_before : float, default: 0.5
-        The left window, before a peak, in milliseconds
-    ms_after : float, default: 0.5
-        The right window, after a peak, in milliseconds
-    spike_retriver_kwargs : dict
-        A dictionary to control the behavior for getting the maximum channel for each spike
-        This dictionary contains:
-          * channel_from_template: bool, default: True
-              For each spike is the maximum channel computed from template or re estimated at every spikes
-              channel_from_template = True is old behavior but less acurate
-              channel_from_template = False is slower but more accurate
-          * radius_um: float, default: 50
-              In case channel_from_template=False, this is the radius to get the true peak
-          * peak_sign, default: "neg"
-              In case channel_from_template=False, this is the peak sign.
-    method : "center_of_mass" | "monopolar_triangulation" | "grid_convolution", default: "center_of_mass"
-        The localization method to use
-    **method_kwargs : dict, default: {}
-        Kwargs which are passed to the method function. These can be found in the docstrings of `compute_center_of_mass`, `compute_grid_convolution` and `compute_monopolar_triangulation`.
-    outputs : "numpy" | "by_unit", default: "numpy"
-        The output format, either concatenated as numpy array or separated on a per unit basis
+    peak_sign : "neg" | "pos" | "both", default: "neg"
+        Sign of the template to compute extremum channel used to retrieve spike amplitudes.
 
     Returns
     -------
-    spike_locations: np.array
-        All locations for all spikes and all units are concatenated
+    spike_amplitudes: np.array
+        All amplitudes for all spikes and all units are concatenated (along time, like in spike vector)
 
     """
 

src/spikeinterface/preprocessing/motion.py

@@ -443,9 +443,6 @@ def compute_motion(
     t1 = time.perf_counter()
     run_times["estimate_motion"] = t1 - t0
 
-    if recording.get_dtype().kind != "f":
-        recording = recording.astype("float32")
-
     motion_info = dict(
         parameters=parameters,
         run_times=run_times,
@@ -554,6 +551,9 @@ def correct_motion(
         **job_kwargs,
     )
 
+    if recording.get_dtype().kind != "f":
+        recording = recording.astype("float32")
+
     recording_corrected = interpolate_motion(recording, motion, **interpolate_motion_kwargs)
 
     if not output_motion and not output_motion_info:

src/spikeinterface/preprocessing/tests/test_motion.py

@@ -32,6 +32,13 @@ def test_estimate_and_correct_motion(create_cache_folder):
     assert motion_info_loaded["motion"] == motion_info["motion"]
 
 
+def test_estimate_and_correct_motion_int():
+
+    rec = generate_recording(durations=[30.0], num_channels=12).astype(int)
+    rec_corrected = correct_motion(rec, estimate_motion_kwargs={"win_step_um": 50, "win_scale_um": 100})
+    assert rec_corrected.get_dtype().kind == "f"
+
+
 def test_get_motion_parameters_preset():
     from pprint import pprint