Remove peak_sign in favour of main_channel_indices

src/spikeinterface/benchmark/benchmark_clustering.py

@@ -11,7 +11,6 @@
 from spikeinterface.core.job_tools import fix_job_kwargs, split_job_kwargs
 from .benchmark_base import Benchmark, BenchmarkStudy, MixinStudyUnitCount
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.template_tools import get_template_extremum_channel
 
 
 class ClusteringBenchmark(Benchmark):

src/spikeinterface/benchmark/tests/test_benchmark_clustering.py

@@ -5,8 +5,6 @@
 
 from spikeinterface.benchmark.tests.common_benchmark_testing import make_dataset
 from spikeinterface.benchmark.benchmark_clustering import ClusteringStudy
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.template_tools import get_template_extremum_channel
 
 from pathlib import Path
 
@@ -33,7 +31,8 @@ def test_benchmark_clustering(create_cache_folder):
 
         # sorting_analyzer = create_sorting_analyzer(gt_sorting, recording, format="memory", sparse=False)
         # sorting_analyzer.compute(["random_spikes", "templates"])
-        extremum_channel_inds = get_template_extremum_channel(gt_analyzer, outputs="index")
+        extremum_channel_inds = gt_analyzer.get_main_channels(outputs="index", with_dict=True)
+
         spikes = gt_analyzer.sorting.to_spike_vector(extremum_channel_inds=extremum_channel_inds)
         peaks[dataset] = spikes
 

src/spikeinterface/benchmark/tests/test_benchmark_peak_detection.py

@@ -6,7 +6,6 @@
 from spikeinterface.benchmark.tests.common_benchmark_testing import make_dataset
 from spikeinterface.benchmark.benchmark_peak_detection import PeakDetectionStudy
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.template_tools import get_template_extremum_channel
 
 
 @pytest.mark.skip()
@@ -30,7 +29,7 @@ def test_benchmark_peak_detection(create_cache_folder):
         sorting_analyzer = create_sorting_analyzer(gt_sorting, recording, format="memory", sparse=False, **job_kwargs)
         sorting_analyzer.compute("random_spikes")
         sorting_analyzer.compute("templates", **job_kwargs)
-        extremum_channel_inds = get_template_extremum_channel(sorting_analyzer, outputs="index")
+        extremum_channel_inds = sorting_analyzer.get_main_channels(outputs="index", with_dict=True)
         spikes = gt_sorting.to_spike_vector(extremum_channel_inds=extremum_channel_inds)
         peaks[dataset] = spikes
 

src/spikeinterface/core/__init__.py

@@ -166,9 +166,12 @@
 # template tools
 from .template_tools import (
     get_template_amplitudes,
-    get_template_extremum_channel,
-    get_template_extremum_channel_peak_shift,
-    get_template_extremum_amplitude,
+    get_template_main_channel_peak_shift,
+    get_template_main_channel_amplitude,
+    # this is not needed anymore
+    get_template_extremum_channel,  # keep for backward compatibility can be removed in 0.106
+    get_template_extremum_channel_peak_shift,  # keep for backward compatibility can be removed in 0.106
+    get_template_extremum_amplitude,  # keep for backward compatibility can be removed in 0.106
 )
 
 

src/spikeinterface/core/analyzer_extension_core.py

@@ -381,7 +381,7 @@ class ComputeTemplates(AnalyzerExtension):
 
     extension_name = "templates"
     depend_on = ["random_spikes|waveforms"]
-    need_recording = True
+    need_recording = False
     use_nodepipeline = False
     need_job_kwargs = True
     need_backward_compatibility_on_load = True

src/spikeinterface/core/basesorting.py

@@ -13,6 +13,10 @@ class BaseSorting(BaseExtractor):
     Abstract class representing several segment several units and relative spiketrains.
     """
 
+    _main_properties = [
+        "main_channel_id",
+    ]
+
     def __init__(self, sampling_frequency: float, unit_ids: list):
         BaseExtractor.__init__(self, unit_ids)
         self._sampling_frequency = float(sampling_frequency)
@@ -913,6 +917,7 @@ def _compute_and_cache_spike_vector(self) -> None:
         self._cached_spike_vector = spikes
         self._cached_spike_vector_segment_slices = segment_slices
 
+    # TODO sam : change extremum_channel_inds to main_channel_index with vector
     def to_spike_vector(
         self,
         concatenated=True,
@@ -933,7 +938,8 @@ def to_spike_vector(
         extremum_channel_inds : None or dict, default: None
             If a dictionnary of unit_id to channel_ind is given then an extra field "channel_index".
             This can be convinient for computing spikes postion after sorter.
-            This dict can be computed with `get_template_extremum_channel(we, outputs="index")`
+            This dict can be given by analyzer.get_main_channels(outputs="index", with_dict=True)
+
         use_cache : bool, default: True
             When True the spikes vector is cached as an attribute of the object (`_cached_spike_vector`).
             This caching only occurs when extremum_channel_inds=None.

src/spikeinterface/core/generate.py

@@ -945,7 +945,9 @@ def inject_some_duplicate_units(sorting, num=4, max_shift=5, ratio=None, seed=No
     """
     rng = np.random.default_rng(seed)
 
-    other_ids = np.arange(np.max(sorting.unit_ids) + 1, np.max(sorting.unit_ids) + num + 1)
+    other_ids = np.arange(
+        np.max(sorting.unit_ids.astype(int)) + 1, np.max(sorting.unit_ids.astype(int)) + num + 1
+    ).astype(sorting.unit_ids.dtype)
     shifts = rng.integers(low=-max_shift, high=max_shift, size=num)
 
     shifts[shifts == 0] += max_shift
@@ -1007,12 +1009,20 @@ def inject_some_split_units(sorting, split_ids: list, num_split=2, output_ids=Fa
         The dictionary with the split unit_ids. Returned only if output_ids is True.
     """
     unit_ids = sorting.unit_ids
-    assert unit_ids.dtype.kind == "i"
 
-    m = np.max(unit_ids) + 1
+    unit_ids_integer = unit_ids.dtype.kind == "i"
+    if not unit_ids_integer:
+        assert np.char.isdigit(unit_ids.astype(str)).all(), "Not all Unit IDs are parsable as integers"
+
+    integer_unit_ids = unit_ids.astype(int)
+
+    m = np.max(integer_unit_ids) + 1
     other_ids = {}
     for unit_id in split_ids:
-        other_ids[unit_id] = np.arange(m, m + num_split, dtype=unit_ids.dtype)
+        new_ids = np.arange(m, m + num_split).astype(int)
+        if not unit_ids_integer:
+            new_ids = [str(new_id) for new_id in new_ids]
+        other_ids[unit_id] = new_ids
         m += num_split
 
     rng = np.random.default_rng(seed)
@@ -2410,6 +2420,9 @@ def generate_ground_truth_recording(
     else:
         num_channels = probe.get_contact_count()
 
+    nbefore = ms_to_samples(ms_before, sampling_frequency)
+    nafter = ms_to_samples(ms_after, sampling_frequency)
+
     if templates is None:
         channel_locations = probe.contact_positions
         unit_locations = generate_unit_locations(
@@ -2427,8 +2440,18 @@ def generate_ground_truth_recording(
             **generate_templates_kwargs,
         )
         sorting.set_property("gt_unit_locations", unit_locations)
+        distances = np.linalg.norm(unit_locations[:, np.newaxis, :2] - channel_locations[np.newaxis, :, :2], axis=2)
+        main_channel_indices = np.argmin(distances, axis=1)
+
     else:
         assert templates.shape[0] == num_units
+        from .template_tools import _get_main_channel_from_template_array
+
+        main_channel_indices = _get_main_channel_from_template_array(
+            templates, peak_mode="extremum", peak_sign="both", nbefore=nbefore
+        )
+
+    assert (nbefore + nafter) == templates.shape[1]
 
     if templates.ndim == 3:
         upsample_vector = None
@@ -2437,10 +2460,6 @@ def generate_ground_truth_recording(
             upsample_factor = templates.shape[3]
             upsample_vector = rng.integers(0, upsample_factor, size=num_spikes)
 
-    nbefore = ms_to_samples(ms_before, sampling_frequency)
-    nafter = ms_to_samples(ms_after, sampling_frequency)
-    assert (nbefore + nafter) == templates.shape[1]
-
     # construct recording
     from spikeinterface.generation.noise_tools import NoiseGeneratorRecording
 
@@ -2466,6 +2485,9 @@ def generate_ground_truth_recording(
     recording.set_channel_gains(1.0)
     recording.set_channel_offsets(0.0)
 
+    main_channel_ids = recording.channel_ids[main_channel_indices]
+    sorting.set_property("main_channel_id", main_channel_ids)
+
     recording.name = "GroundTruthRecording"
     sorting.name = "GroundTruthSorting"
 

src/spikeinterface/core/node_pipeline.py

@@ -145,6 +145,9 @@ def compute(self, traces, start_frame, end_frame, segment_index, max_margin, pea
         return (local_peaks,)
 
 
+# TODO sam replace extremum_channels_indices by main_channel_index
+
+
 # this is not implemented yet this will be done in separted PR
 class SpikeRetriever(PeakSource):
     """

src/spikeinterface/core/sorting_tools.py

@@ -495,6 +495,7 @@ def set_properties_after_merging(
     default_missing_values = BaseExtractor.default_missing_property_values
 
     for key in prop_keys:
+
         parent_values = sorting_pre_merge.get_property(key)
 
         # propagate keep values
@@ -511,6 +512,12 @@ def set_properties_after_merging(
             if same_property_values:
                 # and new values only if they are all similar
                 new_values[new_index] = merge_values[0]
+            elif (not same_property_values) and key == "main_channel_id":
+                # Main channel id is special. For now, if there is a disagreement, we take the value of the unit
+                # with the most spikes. TODO: overwrite this for analyzer if templates exist.
+                num_spikes_per_unit = sorting_pre_merge.count_num_spikes_per_unit(unit_ids=merge_group)
+                max_unit_index = np.argmax(num_spikes_per_unit.values())
+                new_values[new_index] = merge_values[max_unit_index]
             else:
                 if parent_values.dtype.kind not in default_missing_values:
                     # if the property doesn't have a default missing value and it is not the same