From 0087705fcf5a27a0d5faedd58e93f7bfa80a0f0c Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 29 May 2024 16:53:27 +0200
Subject: [PATCH 001/164] WIP

---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 05853b4c39..705ce0cf1d 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -11,7 +11,6 @@
 from spikeinterface.core.job_tools import fix_job_kwargs
 from spikeinterface.core.recording_tools import get_noise_levels
 from spikeinterface.core.template import Templates
-from spikeinterface.core.template_tools import get_template_extremum_amplitude
 from spikeinterface.core.waveform_tools import estimate_templates
 from spikeinterface.preprocessing import common_reference, whiten, bandpass_filter, correct_motion
 from spikeinterface.sortingcomponents.tools import cache_preprocessing
@@ -48,10 +47,9 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
         "merging": {
-            "minimum_spikes": 10,
-            "corr_diff_thresh": 0.5,
+            "minimum_spikes": 100,
+            "corr_diff_thresh": 0.25,
             "template_metric": "cosine",
-            "censor_correlograms_ms": 0.4,
             "num_channels": None,
         },
         "clustering": {"legacy": True},

From 57f40d837d12e36e60d1d51cf72bd149c81fcd78 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 11:40:47 +0200
Subject: [PATCH 002/164] Starting to reformat merging methods

---
 src/spikeinterface/generation/drift_tools.py  | 44 ++++++++++++
 .../sorters/internal/spyking_circus2.py       | 10 ++-
 .../benchmark/benchmark_merging.py            | 51 ++++++++++++++
 .../clustering/clustering_tools.py            | 67 -------------------
 .../sortingcomponents/merging/__init__.py     |  3 +
 .../sortingcomponents/merging/circus.py       | 47 +++++++++++++
 .../sortingcomponents/merging/main.py         | 61 +++++++++++++++++
 .../sortingcomponents/merging/method_list.py  |  7 ++
 .../sortingcomponents/merging/tools.py        | 67 +++++++++++++++++++
 9 files changed, 284 insertions(+), 73 deletions(-)
 create mode 100644 src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
 create mode 100644 src/spikeinterface/sortingcomponents/merging/__init__.py
 create mode 100644 src/spikeinterface/sortingcomponents/merging/circus.py
 create mode 100644 src/spikeinterface/sortingcomponents/merging/main.py
 create mode 100644 src/spikeinterface/sortingcomponents/merging/method_list.py
 create mode 100644 src/spikeinterface/sortingcomponents/merging/tools.py

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index bb73e0fced..ae3a5dd295 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -513,3 +513,47 @@ def get_traces(
 
     def get_num_samples(self) -> int:
         return self.num_samples
+
+
+def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
+    """
+    Fonction used to split a sorting based on the amplitudes of the units. This
+    might be used for benchmarking meta merging step (see components)
+    """
+
+    if sorting_analyzer.get_extension('spike_amplitudes') is None:
+        sorting_analyzer.compute("spike_amplitudes")
+
+    sa = sorting_analyzer
+
+    from spikeinterface.core.numpyextractors import NumpySorting
+    from spikeinterface.core.template_tools import get_template_extremum_channel
+    extremum_channel_inds = get_template_extremum_channel(sa, outputs="index")
+    spikes = sa.sorting.to_spike_vector(extremum_channel_inds=extremum_channel_inds)
+    new_spikes = spikes.copy()
+    amplitudes = sa.get_extension('spike_amplitudes').get_data()
+    nb_splits = int(splitting_probability*len(sa.sorting.unit_ids))
+    to_split_ids = np.random.choice(sa.sorting.unit_ids, nb_splits, replace=False)
+    max_index = np.max(spikes['unit_index'])
+    new_unit_ids = list(sa.sorting.unit_ids.copy())
+    splitted_pairs = []
+    for unit_id in to_split_ids:
+        ind_mask = spikes['unit_index'] == sa.sorting.id_to_index(unit_id)
+
+        m = amplitudes[ind_mask].mean()
+        s = amplitudes[ind_mask].std()
+        thresh = m + 0.2*s
+
+        amplitude_mask = (amplitudes > thresh)
+        mask = ind_mask & amplitude_mask
+        new_spikes['unit_index'][mask] = max_index + 1
+
+        amplitude_mask = (amplitudes > m) * (amplitudes < thresh)
+        mask = ind_mask & amplitude_mask
+        new_spikes['unit_index'][mask] = (max_index + 1)*np.random.rand(np.sum(mask)) > 0.5
+        max_index += 1
+        new_unit_ids += [max(new_unit_ids)+1]
+        splitted_pairs += [(unit_id, new_unit_ids[-1])]
+
+    new_sorting = NumpySorting(new_spikes, sampling_frequency=sa.sampling_frequency, unit_ids=new_unit_ids)
+    return new_sorting, splitted_pairs
\ No newline at end of file
diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 705ce0cf1d..da2250102c 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -16,10 +16,6 @@
 from spikeinterface.sortingcomponents.tools import cache_preprocessing
 from spikeinterface.core.basesorting import minimum_spike_dtype
 from spikeinterface.core.sparsity import compute_sparsity
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-
 
 try:
     import hdbscan
@@ -47,9 +43,10 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
         "merging": {
-            "minimum_spikes": 100,
-            "corr_diff_thresh": 0.25,
+            "minimum_spikes": 10,
+            "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
+            "censor_correlograms_ms": 0.4,
             "num_channels": None,
         },
         "clustering": {"legacy": True},
@@ -105,6 +102,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         from spikeinterface.sortingcomponents.peak_selection import select_peaks
         from spikeinterface.sortingcomponents.clustering import find_cluster_from_peaks
         from spikeinterface.sortingcomponents.matching import find_spikes_from_templates
+        from spikeinterface.sortingcomponents.merging import merge_spikes
         from spikeinterface.sortingcomponents.tools import remove_empty_templates
         from spikeinterface.sortingcomponents.tools import get_prototype_spike, check_probe_for_drift_correction
         from spikeinterface.sortingcomponents.tools import get_prototype_spike
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
new file mode 100644
index 0000000000..76124c54a9
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from spikeinterface.sortingcomponents.matching import find_spikes_from_templates
+from spikeinterface.core import NumpySorting
+from spikeinterface.comparison import CollisionGTComparison, compare_sorter_to_ground_truth
+from spikeinterface.widgets import (
+    plot_agreement_matrix,
+    plot_comparison_collision_by_similarity,
+)
+
+import pylab as plt
+import matplotlib.patches as mpatches
+import numpy as np
+from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy
+from spikeinterface.core.basesorting import minimum_spike_dtype
+
+
+class MergingBenchmark(Benchmark):
+
+    def __init__(self, recording, splitted_sorting, params):
+        self.recording = recording
+        self.splitted_sorting = splitted_sorting
+        self.method = params["method"]
+        self.gt_sorting = params["method_kwargs"]["gt_sorting"]
+        self.method_kwargs = params["method_kwargs"]
+        self.result = {}
+
+    def run(self, **job_kwargs):
+        pass
+
+    def compute_result(self, **result_params):
+        sorting = self.result["sorting"]
+        comp = compare_sorter_to_ground_truth(self.gt_sorting, sorting, exhaustive_gt=True)
+        self.result["gt_comparison"] = comp
+        
+    _run_key_saved = [
+        ("sorting", "sorting"),
+    ]
+    _result_key_saved = [("gt_comparison", "pickle")]
+
+
+class MergingStudy(BenchmarkStudy):
+
+    benchmark_class = MergingBenchmark
+
+    def create_benchmark(self, key):
+        dataset_key = self.cases[key]["dataset"]
+        recording, gt_sorting = self.datasets[dataset_key]
+        params = self.cases[key]["params"]
+        benchmark = MergingBenchmark(recording, gt_sorting, params)
+        return benchmark
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/clustering/clustering_tools.py b/src/spikeinterface/sortingcomponents/clustering/clustering_tools.py
index 4bc717c577..18fb7d198e 100644
--- a/src/spikeinterface/sortingcomponents/clustering/clustering_tools.py
+++ b/src/spikeinterface/sortingcomponents/clustering/clustering_tools.py
@@ -8,7 +8,6 @@
 import numpy as np
 from spikeinterface.core.job_tools import fix_job_kwargs
 from spikeinterface.postprocessing import check_equal_template_with_distribution_overlap
-from spikeinterface.core import NumpySorting
 
 
 def _split_waveforms(
@@ -685,72 +684,6 @@ def remove_duplicates_via_matching(
     return labels, new_labels
 
 
-def resolve_merging_graph(sorting, potential_merges):
-    """
-    Function to provide, given a list of potential_merges, a resolved merging
-    graph based on the connected components.
-    """
-    from scipy.sparse.csgraph import connected_components
-    from scipy.sparse import lil_matrix
-
-    n = len(sorting.unit_ids)
-    graph = lil_matrix((n, n))
-    for i, j in potential_merges:
-        graph[sorting.id_to_index(i), sorting.id_to_index(j)] = 1
-
-    n_components, labels = connected_components(graph, directed=True, connection="weak", return_labels=True)
-    final_merges = []
-    for i in range(n_components):
-        merges = labels == i
-        if merges.sum() > 1:
-            final_merges += [list(sorting.unit_ids[np.flatnonzero(merges)])]
-
-    return final_merges
-
-
-def apply_merges_to_sorting(sorting, merges, censor_ms=0.4):
-    """
-    Function to apply a resolved representation of the merges to a sorting object. If censor_ms is not None,
-    duplicated spikes violating the censor_ms refractory period are removed
-    """
-    spikes = sorting.to_spike_vector().copy()
-    to_keep = np.ones(len(spikes), dtype=bool)
-
-    segment_slices = {}
-    for segment_index in range(sorting.get_num_segments()):
-        s0, s1 = np.searchsorted(spikes["segment_index"], [segment_index, segment_index + 1], side="left")
-        segment_slices[segment_index] = (s0, s1)
-
-    if censor_ms is not None:
-        rpv = int(sorting.sampling_frequency * censor_ms / 1000)
-
-    for connected in merges:
-        mask = np.in1d(spikes["unit_index"], sorting.ids_to_indices(connected))
-        spikes["unit_index"][mask] = sorting.id_to_index(connected[0])
-
-        if censor_ms is not None:
-            for segment_index in range(sorting.get_num_segments()):
-                s0, s1 = segment_slices[segment_index]
-                (indices,) = s0 + np.nonzero(mask[s0:s1])
-                to_keep[indices[1:]] = np.logical_or(
-                    to_keep[indices[1:]], np.diff(spikes[indices]["sample_index"]) > rpv
-                )
-
-    times_list = []
-    labels_list = []
-    for segment_index in range(sorting.get_num_segments()):
-        s0, s1 = segment_slices[segment_index]
-        if censor_ms is not None:
-            times_list += [spikes["sample_index"][s0:s1][to_keep[s0:s1]]]
-            labels_list += [spikes["unit_index"][s0:s1][to_keep[s0:s1]]]
-        else:
-            times_list += [spikes["sample_index"][s0:s1]]
-            labels_list += [spikes["unit_index"][s0:s1]]
-
-    sorting = NumpySorting.from_times_labels(times_list, labels_list, sorting.sampling_frequency)
-    return sorting
-
-
 def remove_duplicates_via_dip(wfs_arrays, peak_labels, dip_threshold=1, cosine_threshold=None):
     import sklearn
 
diff --git a/src/spikeinterface/sortingcomponents/merging/__init__.py b/src/spikeinterface/sortingcomponents/merging/__init__.py
new file mode 100644
index 0000000000..5c1b5498d7
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/__init__.py
@@ -0,0 +1,3 @@
+from .method_list import merging_methods
+
+from .main import merge_spikes
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
new file mode 100644
index 0000000000..7799794bf8
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+import numpy as np
+
+from .main import BaseMergingEngine
+from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
+from spikeinterface.core.analyzer_extension_core import ComputeTemplates
+from spikeinterface.curation.auto_merge import get_potential_auto_merge
+from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
+
+class CircusMerging(BaseMergingEngine):
+    """
+    TO DO
+    """
+
+    default_params = {
+        'templates' : None
+    }
+    
+
+    @classmethod
+    def initialize_and_check_kwargs(cls, recording, sorting, kwargs):
+        d = cls.default_params.copy()
+        d.update(kwargs)
+        templates = d.get('templates', None)
+        if templates is not None:
+            sparsity = templates.sparsity
+            templates_array = templates.get_dense_templates().copy()
+            sa = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
+            sa.extensions["templates"] = ComputeTemplates(sa)
+            sa.extensions["templates"].params = {"nbefore": templates.nbefore}
+            sa.extensions["templates"].data["average"] = templates_array
+            sa.compute("unit_locations", method="monopolar_triangulation")
+        else:
+            sa = create_sorting_analyzer(sorting, recording, format="memory")
+            sa.compute(['random_spikes', 'templates'])
+            sa.compute("unit_locations", method="monopolar_triangulation")
+        
+        d['analyzer'] = sa
+        return d
+
+    @classmethod
+    def main_function(cls, recording, sorting, method_kwargs):
+        analyzer = method_kwargs.pop('analyzer')
+        merges = get_potential_auto_merge(analyzer, **method_kwargs)
+        merges = resolve_merging_graph(sorting, merges)
+        sorting = apply_merges_to_sorting(sorting, merges)
+        return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
new file mode 100644
index 0000000000..22d0981fdc
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from threadpoolctl import threadpool_limits
+import numpy as np
+
+
+
+def merge_spikes(
+    recording, sorting, method="circus", method_kwargs={}, extra_outputs=False, verbose=False, **job_kwargs
+):
+    """Find spike from a recording from given templates.
+
+    Parameters
+    ----------
+    recording: RecordingExtractor
+        The recording extractor object
+    sorting: Sorting
+        The NumpySorting object
+    method: "circus"
+        Which method to use for merging spikes
+    method_kwargs: dict, optional
+        Keyword arguments for the chosen method
+    extra_outputs: bool
+        If True then method_kwargs is also returned
+
+    Returns
+    -------
+    new_sorting: NumpySorting
+        Sorting found after merging
+    method_kwargs:
+        Optionaly returns for debug purpose.
+
+    """
+    from .method_list import merging_methods
+
+    assert method in merging_methods, f"The 'method' {method} is not valid. Use a method from {merging_methods}"
+
+    method_class = merging_methods[method]
+    method_kwargs = method_class.initialize_and_check_kwargs(recording, sorting, method_kwargs)
+    new_sorting = method_class.main_function(recording, sorting, method_kwargs)
+
+    if extra_outputs:
+        return new_sorting, method_kwargs
+    else:
+        return new_sorting
+
+
+# generic class for template engine
+class BaseMergingEngine:
+    default_params = {}
+
+    @classmethod
+    def initialize_and_check_kwargs(cls, recording, sorting, kwargs):
+        """This function runs before loops"""
+        # need to be implemented in subclass
+        raise NotImplementedError
+
+    @classmethod
+    def main_function(cls, recording, sorting, method_kwargs):
+        # need to be implemented in subclass
+        raise NotImplementedError
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
new file mode 100644
index 0000000000..72e8a9b223
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .circus import CircusMerging
+
+merging_methods = {
+    "circus" : CircusMerging,
+}
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
new file mode 100644
index 0000000000..ba3bb4a033
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -0,0 +1,67 @@
+import numpy as np
+from spikeinterface.core import NumpySorting
+
+def resolve_merging_graph(sorting, potential_merges):
+    """
+    Function to provide, given a list of potential_merges, a resolved merging
+    graph based on the connected components.
+    """
+    from scipy.sparse.csgraph import connected_components
+    from scipy.sparse import lil_matrix
+
+    n = len(sorting.unit_ids)
+    graph = lil_matrix((n, n))
+    for i, j in potential_merges:
+        graph[sorting.id_to_index(i), sorting.id_to_index(j)] = 1
+
+    n_components, labels = connected_components(graph, directed=True, connection="weak", return_labels=True)
+    final_merges = []
+    for i in range(n_components):
+        merges = labels == i
+        if merges.sum() > 1:
+            final_merges += [list(sorting.unit_ids[np.flatnonzero(merges)])]
+
+    return final_merges
+
+
+def apply_merges_to_sorting(sorting, merges, censor_ms=0.4):
+    """
+    Function to apply a resolved representation of the merges to a sorting object. If censor_ms is not None,
+    duplicated spikes violating the censor_ms refractory period are removed
+    """
+    spikes = sorting.to_spike_vector().copy()
+    to_keep = np.ones(len(spikes), dtype=bool)
+
+    segment_slices = {}
+    for segment_index in range(sorting.get_num_segments()):
+        s0, s1 = np.searchsorted(spikes["segment_index"], [segment_index, segment_index + 1], side="left")
+        segment_slices[segment_index] = (s0, s1)
+
+    if censor_ms is not None:
+        rpv = int(sorting.sampling_frequency * censor_ms / 1000)
+
+    for connected in merges:
+        mask = np.in1d(spikes["unit_index"], sorting.ids_to_indices(connected))
+        spikes["unit_index"][mask] = sorting.id_to_index(connected[0])
+
+        if censor_ms is not None:
+            for segment_index in range(sorting.get_num_segments()):
+                s0, s1 = segment_slices[segment_index]
+                (indices,) = s0 + np.nonzero(mask[s0:s1])
+                to_keep[indices[1:]] = np.logical_or(
+                    to_keep[indices[1:]], np.diff(spikes[indices]["sample_index"]) > rpv
+                )
+
+    times_list = []
+    labels_list = []
+    for segment_index in range(sorting.get_num_segments()):
+        s0, s1 = segment_slices[segment_index]
+        if censor_ms is not None:
+            times_list += [spikes["sample_index"][s0:s1][to_keep[s0:s1]]]
+            labels_list += [spikes["unit_index"][s0:s1][to_keep[s0:s1]]]
+        else:
+            times_list += [spikes["sample_index"][s0:s1]]
+            labels_list += [spikes["unit_index"][s0:s1]]
+
+    sorting = NumpySorting.from_times_labels(times_list, labels_list, sorting.sampling_frequency)
+    return sorting
\ No newline at end of file

From ec92c01fcf4cfcf13468589c55b6818ccf4521aa Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 11:50:32 +0200
Subject: [PATCH 003/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 3 ++-
 src/spikeinterface/sortingcomponents/merging/main.py   | 2 --
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 7799794bf8..4939027177 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -9,7 +9,7 @@
 
 class CircusMerging(BaseMergingEngine):
     """
-    TO DO
+    Meta merging inspired from the Lussac metric
     """
 
     default_params = {
@@ -41,6 +41,7 @@ def initialize_and_check_kwargs(cls, recording, sorting, kwargs):
     @classmethod
     def main_function(cls, recording, sorting, method_kwargs):
         analyzer = method_kwargs.pop('analyzer')
+        method_kwargs.pop('templates')
         merges = get_potential_auto_merge(analyzer, **method_kwargs)
         merges = resolve_merging_graph(sorting, merges)
         sorting = apply_merges_to_sorting(sorting, merges)
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index 22d0981fdc..06eeef71b2 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -3,8 +3,6 @@
 from threadpoolctl import threadpool_limits
 import numpy as np
 
-
-
 def merge_spikes(
     recording, sorting, method="circus", method_kwargs={}, extra_outputs=False, verbose=False, **job_kwargs
 ):

From 8e39954c84389c6bcf053fa032bbdc7070b21780 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 12:05:32 +0200
Subject: [PATCH 004/164] WIP

---
 .../sortingcomponents/merging/circus.py       | 47 ++++++++-----------
 .../sortingcomponents/merging/main.py         | 10 ++--
 2 files changed, 24 insertions(+), 33 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4939027177..f8ab3b141e 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,33 +16,26 @@ class CircusMerging(BaseMergingEngine):
         'templates' : None
     }
     
-
-    @classmethod
-    def initialize_and_check_kwargs(cls, recording, sorting, kwargs):
-        d = cls.default_params.copy()
-        d.update(kwargs)
-        templates = d.get('templates', None)
-        if templates is not None:
-            sparsity = templates.sparsity
-            templates_array = templates.get_dense_templates().copy()
-            sa = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
-            sa.extensions["templates"] = ComputeTemplates(sa)
-            sa.extensions["templates"].params = {"nbefore": templates.nbefore}
-            sa.extensions["templates"].data["average"] = templates_array
-            sa.compute("unit_locations", method="monopolar_triangulation")
+    def __init__(self, recording, sorting, kwargs):
+        self.default_params.update(**kwargs)
+        self.sorting = sorting
+        self.recording = recording
+        self.templates = self.default_params.pop('templates', None)
+        if self.templates is not None:
+            sparsity = self.templates.sparsity
+            templates_array = self.templates.get_dense_templates().copy()
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
+            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
+            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
+            self.analyzer.extensions["templates"].data["average"] = templates_array
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
         else:
-            sa = create_sorting_analyzer(sorting, recording, format="memory")
-            sa.compute(['random_spikes', 'templates'])
-            sa.compute("unit_locations", method="monopolar_triangulation")
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
+            self.analyzer.compute(['random_spikes', 'templates'])
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
         
-        d['analyzer'] = sa
-        return d
-
-    @classmethod
-    def main_function(cls, recording, sorting, method_kwargs):
-        analyzer = method_kwargs.pop('analyzer')
-        method_kwargs.pop('templates')
-        merges = get_potential_auto_merge(analyzer, **method_kwargs)
-        merges = resolve_merging_graph(sorting, merges)
-        sorting = apply_merges_to_sorting(sorting, merges)
+    def run(self):
+        merges = get_potential_auto_merge(self.analyzer, **self.default_params)
+        merges = resolve_merging_graph(self.sorting, merges)
+        sorting = apply_merges_to_sorting(self.sorting, merges)
         return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index 06eeef71b2..c52d0d508b 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -34,8 +34,8 @@ def merge_spikes(
     assert method in merging_methods, f"The 'method' {method} is not valid. Use a method from {merging_methods}"
 
     method_class = merging_methods[method]
-    method_kwargs = method_class.initialize_and_check_kwargs(recording, sorting, method_kwargs)
-    new_sorting = method_class.main_function(recording, sorting, method_kwargs)
+    method_instance = method_class(recording, sorting, method_kwargs)
+    new_sorting = method_instance.run()
 
     if extra_outputs:
         return new_sorting, method_kwargs
@@ -47,13 +47,11 @@ def merge_spikes(
 class BaseMergingEngine:
     default_params = {}
 
-    @classmethod
-    def initialize_and_check_kwargs(cls, recording, sorting, kwargs):
+    def __init__(self, recording, sorting, kwargs):
         """This function runs before loops"""
         # need to be implemented in subclass
         raise NotImplementedError
 
-    @classmethod
-    def main_function(cls, recording, sorting, method_kwargs):
+    def run(self):
         # need to be implemented in subclass
         raise NotImplementedError
\ No newline at end of file

From f0d83783d08790c5b186ecd18c9d964fe10e3780 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 12:13:22 +0200
Subject: [PATCH 005/164] WIP

---
 .../benchmark/benchmark_merging.py            | 28 +++++++++++++++----
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 76124c54a9..838230f191 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from spikeinterface.sortingcomponents.matching import find_spikes_from_templates
+from spikeinterface.sortingcomponents.merging import merge_spikes
 from spikeinterface.core import NumpySorting
 from spikeinterface.comparison import CollisionGTComparison, compare_sorter_to_ground_truth
 from spikeinterface.widgets import (
@@ -17,16 +17,18 @@
 
 class MergingBenchmark(Benchmark):
 
-    def __init__(self, recording, splitted_sorting, params):
+    def __init__(self, recording, splitted_sorting, params, gt_sorting):
         self.recording = recording
         self.splitted_sorting = splitted_sorting
         self.method = params["method"]
-        self.gt_sorting = params["method_kwargs"]["gt_sorting"]
+        self.gt_sorting = gt_sorting
         self.method_kwargs = params["method_kwargs"]
         self.result = {}
 
     def run(self, **job_kwargs):
-        pass
+        self.result['sorting'] = merge_spikes(
+            self.recording, self.splitted_sorting, method=self.method, method_kwargs=self.method_kwargs
+        )
 
     def compute_result(self, **result_params):
         sorting = self.result["sorting"]
@@ -47,5 +49,19 @@ def create_benchmark(self, key):
         dataset_key = self.cases[key]["dataset"]
         recording, gt_sorting = self.datasets[dataset_key]
         params = self.cases[key]["params"]
-        benchmark = MergingBenchmark(recording, gt_sorting, params)
-        return benchmark
\ No newline at end of file
+        init_kwargs = self.cases[key]["init_kwargs"]
+        benchmark = MergingBenchmark(recording, gt_sorting, params, **init_kwargs)
+        return benchmark
+
+    def plot_agreements(self, case_keys=None, figsize=(15, 15)):
+        if case_keys is None:
+            case_keys = list(self.cases.keys())
+
+        fig, axs = plt.subplots(ncols=len(case_keys), nrows=1, figsize=figsize, squeeze=False)
+
+        for count, key in enumerate(case_keys):
+            ax = axs[0, count]
+            ax.set_title(self.cases[key]["label"])
+            plot_agreement_matrix(self.get_result(key)["gt_comparison"], ax=ax)
+
+        return fig
\ No newline at end of file

From f453437b84835e3661ad2c3fc6530519989c06d6 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 13:12:00 +0200
Subject: [PATCH 006/164] WIP

---
 .../benchmark/benchmark_merging.py            |  43 +++++-
 .../sortingcomponents/merging/drift.py        | 145 ++++++++++++++++++
 .../sortingcomponents/merging/lussac.py       | 109 +++++++++++++
 .../sortingcomponents/merging/method_list.py  |   4 +
 4 files changed, 300 insertions(+), 1 deletion(-)
 create mode 100644 src/spikeinterface/sortingcomponents/merging/drift.py
 create mode 100644 src/spikeinterface/sortingcomponents/merging/lussac.py

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 838230f191..f3a2bbacd8 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -53,6 +53,42 @@ def create_benchmark(self, key):
         benchmark = MergingBenchmark(recording, gt_sorting, params, **init_kwargs)
         return benchmark
 
+    def get_count_units(self, case_keys=None, well_detected_score=None, redundant_score=None, overmerged_score=None):
+        import pandas as pd
+
+        if case_keys is None:
+            case_keys = list(self.cases.keys())
+
+        if isinstance(case_keys[0], str):
+            index = pd.Index(case_keys, name=self.levels)
+        else:
+            index = pd.MultiIndex.from_tuples(case_keys, names=self.levels)
+
+        columns = ["num_gt", "num_sorter", "num_well_detected"]
+        comp = self.get_result(case_keys[0])["gt_comparison"]
+        if comp.exhaustive_gt:
+            columns.extend(["num_false_positive", "num_redundant", "num_overmerged", "num_bad"])
+        count_units = pd.DataFrame(index=index, columns=columns, dtype=int)
+
+        for key in case_keys:
+            comp = self.get_result(key)["gt_comparison"]
+            assert comp is not None, "You need to do study.run_comparisons() first"
+
+            gt_sorting = comp.sorting1
+            sorting = comp.sorting2
+
+            count_units.loc[key, "num_gt"] = len(gt_sorting.get_unit_ids())
+            count_units.loc[key, "num_sorter"] = len(sorting.get_unit_ids())
+            count_units.loc[key, "num_well_detected"] = comp.count_well_detected_units(well_detected_score)
+
+            if comp.exhaustive_gt:
+                count_units.loc[key, "num_redundant"] = comp.count_redundant_units(redundant_score)
+                count_units.loc[key, "num_overmerged"] = comp.count_overmerged_units(overmerged_score)
+                count_units.loc[key, "num_false_positive"] = comp.count_false_positive_units(redundant_score)
+                count_units.loc[key, "num_bad"] = comp.count_bad_units()
+
+        return count_units
+
     def plot_agreements(self, case_keys=None, figsize=(15, 15)):
         if case_keys is None:
             case_keys = list(self.cases.keys())
@@ -64,4 +100,9 @@ def plot_agreements(self, case_keys=None, figsize=(15, 15)):
             ax.set_title(self.cases[key]["label"])
             plot_agreement_matrix(self.get_result(key)["gt_comparison"], ax=ax)
 
-        return fig
\ No newline at end of file
+        return fig
+
+    def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
+        from spikeinterface.widgets.widget_list import plot_study_unit_counts
+
+        plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
new file mode 100644
index 0000000000..6efb370b4e
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -0,0 +1,145 @@
+from __future__ import annotations
+import numpy as np
+import lussac.utils as utils
+
+from .main import BaseMergingEngine
+from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
+from spikeinterface.core.analyzer_extension_core import ComputeTemplates
+from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
+
+
+def compute_presence_distance(analyzer, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
+    """
+    Compute the presence distance between two units.
+
+    The presence distance is defined as the sum of the absolute difference between the sum of 
+    the normalized firing profiles of the two units and a constant firing profile.
+
+    Parameters
+    ----------
+    analyzer: SortingAnalyzer
+        The sorting analyzer object.
+    unit1: int or str
+        The id of the first unit.
+    unit2: int or str
+        The id of the second unit.
+    bin_duration_s: float
+        The duration of the bin in seconds.
+    percentile_norm: float
+        The percentile used to normalize the firing rate.
+    bins: array-like
+        The bins used to compute the firing rate.
+
+    Returns
+    -------
+    d: float
+        The presence distance between the two units.
+    """
+    if bins is None:
+        bin_size = bin_duration_s * analyzer.sampling_frequency
+        bins = np.arange(0, analyzer.get_num_samples(), bin_size)
+
+    st1 = analyzer.sorting.get_unit_spike_train(unit_id=unit1)
+    st2 = analyzer.sorting.get_unit_spike_train(unit_id=unit2)
+
+    h1, _ = np.histogram(st1, bins)
+    h1 = h1.astype(float)
+    norm_value1 = np.percentile(h1, percentile_norm)
+
+    h2, _ = np.histogram(st2, bins)
+    h2 = h2.astype(float)
+    norm_value2 = np.percentile(h2, percentile_norm)
+
+    if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
+        h1 = h1 / norm_value1
+        h2 = h2 / norm_value2
+        d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / analyzer.get_total_duration()
+    else:
+        d = np.nan
+    
+    return d
+
+
+def get_potential_drift_merges(analyzer, similarity_threshold=0.7, presence_distance_threshold=0.1, bin_duration_s=2):
+    """
+    Get the potential drift-related merges based on similarity and presence completeness.
+
+    Parameters
+    ----------
+    analyzer: SortingAnalyzer
+        The sorting analyzer object
+    similarity_threshold: float
+        The similarity threshold used to consider two units as similar
+    presence_distance_threshold: float
+        The presence distance threshold used to consider two units as similar
+    bin_duration_s: float
+        The duration of the bin in seconds
+
+    Returns
+    -------
+    potential_merges: list
+        The list of potential merges
+    
+    """
+    assert analyzer.get_extension("templates") is not None, "The templates extension is required"
+    assert analyzer.get_extension("template_similarity") is not None, "The template_similarity extension is required"
+    distances = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+    similarity = analyzer.get_extension("template_similarity").get_data()
+
+    bin_size = bin_duration_s * analyzer.sampling_frequency
+    bins = np.arange(0, analyzer.get_num_samples(), bin_size)
+
+    for i, unit1 in enumerate(analyzer.unit_ids):
+        for j, unit2 in enumerate(analyzer.unit_ids):    
+            if i != j and similarity[i, j] > similarity_threshold:
+                d = compute_presence_distance(analyzer, unit1, unit2, bins=bins)
+                distances[i, j] = d
+            else:
+                distances[i, j] = 1
+    distance_thr = np.triu(distances)
+    distance_thr[distance_thr == 0] = np.nan
+    distance_thr[similarity < similarity_threshold] = np.nan
+    distance_thr[distance_thr > presence_distance_threshold] = np.nan
+    potential_merges = analyzer.unit_ids[np.array(np.nonzero(np.logical_not(np.isnan(distance_thr)))).T]
+    potential_merges = [tuple(merge) for merge in potential_merges]
+
+    return potential_merges
+
+
+
+class DriftMerging(BaseMergingEngine):
+    """
+    Meta merging inspired from the Lussac metric
+    """
+
+    default_params = {
+        'templates' : None,
+        'similarity_threshold' : 0.7, 
+        'presence_distance_threshold' : 0.1, 
+        'bin_duration_s' : 2
+    }
+    
+    def __init__(self, recording, sorting, kwargs):
+        self.default_params.update(**kwargs)
+        self.sorting = sorting
+        self.recording = recording
+        self.templates = self.default_params.pop('templates', None)
+        if self.templates is not None:
+            sparsity = self.templates.sparsity
+            templates_array = self.templates.get_dense_templates().copy()
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
+            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
+            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
+            self.analyzer.extensions["templates"].data["average"] = templates_array
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+        else:
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
+            self.analyzer.compute(['random_spikes', 'templates'])
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+        self.analyzer.compute(['template_similarity'])
+
+    def run(self):
+        merges = get_potential_drift_merges(self.analyzer, **self.default_params)
+        merges = resolve_merging_graph(self.sorting, merges)
+        sorting = apply_merges_to_sorting(self.sorting, merges)
+        return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
new file mode 100644
index 0000000000..573cd4fff8
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+import numpy as np
+import lussac.utils as utils
+
+from .main import BaseMergingEngine
+from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
+from spikeinterface.core.analyzer_extension_core import ComputeTemplates
+from spikeinterface.curation.auto_merge import get_potential_auto_merge
+from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
+
+
+def aurelien_merge(analyzer, refractory_period, template_threshold: float = 0.12, CC_threshold: float = 0.15,
+                   max_shift: int = 10, max_channels: int = 10) -> list[tuple]:
+    """
+    Looks at a sorting analyzer, and returns a list of potential pairwise merges.
+
+    Parameters
+    ----------
+    analyzer: SortingAnalyzer
+        The analyzer to look at
+    refractory_period: array/list/tuple of 2 floats
+        (censored_period_ms, refractory_period_ms)
+    template_threshold: float
+        The threshold on the template difference.
+        Any pair above this threshold will not be considered.
+    CC_treshold: float
+        The threshold on the cross-contamination.
+        Any pair above this threshold will not be considered.
+    max_shift: int
+        The maximum shift when comparing the templates (in number of time samples).
+    max_channels: int
+        The maximum number of channels to consider when comparing the templates.
+    """
+    
+    pairs = []
+    sorting = analyzer.sorting
+    recording = analyzer.recording
+    utils.Utils.t_max = recording.get_num_frames()
+    utils.Utils.sampling_frequency = recording.sampling_frequency
+
+    for unit_id1 in analyzer.unit_ids:
+        for unit_id2 in analyzer.unit_ids:
+            if unit_id2 <= unit_id1:
+                continue
+
+            # Computing template difference
+            template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
+            template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
+    
+            best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:10]
+            
+            max_diff = 1
+            for shift in range(-max_shift, max_shift+1):
+                n = len(template1)
+                t1 = template1[max_shift: n-max_shift, best_channel_indices]
+                t2 = template2[max_shift+shift: n-max_shift+shift, best_channel_indices]
+                diff = np.sum(np.abs(t1 - t2)) / np.sum(np.abs(t1) + np.abs(t2))
+                if diff < max_diff:
+                    max_diff = diff
+
+            if max_diff > template_threshold:
+                continue
+
+            # Compuyting the cross-contamination difference
+            spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
+            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
+            CC = utils.estimate_cross_contamination(spike_train1, spike_train2, refractory_period)
+
+            if CC > CC_threshold:
+                continue
+
+            pairs.append((unit_id1, unit_id2))
+
+    return pairs
+
+
+class LussacMerging(BaseMergingEngine):
+    """
+    Meta merging inspired from the Lussac metric
+    """
+
+    default_params = {
+        'templates' : None,
+        'refractory_period' : (0.4, 1.9)
+    }
+    
+    def __init__(self, recording, sorting, kwargs):
+        self.default_params.update(**kwargs)
+        self.sorting = sorting
+        self.recording = recording
+        self.templates = self.default_params.pop('templates', None)
+        if self.templates is not None:
+            sparsity = self.templates.sparsity
+            templates_array = self.templates.get_dense_templates().copy()
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
+            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
+            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
+            self.analyzer.extensions["templates"].data["average"] = templates_array
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+        else:
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
+            self.analyzer.compute(['random_spikes', 'templates'])
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+        
+    def run(self):
+        merges = aurelien_merge(self.analyzer, **self.default_params)
+        merges = resolve_merging_graph(self.sorting, merges)
+        sorting = apply_merges_to_sorting(self.sorting, merges)
+        return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index 72e8a9b223..52ab0accf0 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -1,7 +1,11 @@
 from __future__ import annotations
 
 from .circus import CircusMerging
+from .lussac import LussacMerging
+from .drift import DriftMerging
 
 merging_methods = {
     "circus" : CircusMerging,
+    "lussac" : LussacMerging,
+    "drift" : DriftMerging
 }

From d5a541dc29b21220310231dec803731e5dfc1e0a Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 30 May 2024 11:23:01 +0000
Subject: [PATCH 007/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/generation/drift_tools.py  | 23 ++++++------
 .../benchmark/benchmark_merging.py            |  6 ++--
 .../sortingcomponents/merging/circus.py       | 13 ++++---
 .../sortingcomponents/merging/drift.py        | 25 +++++++------
 .../sortingcomponents/merging/lussac.py       | 35 ++++++++++---------
 .../sortingcomponents/merging/main.py         |  3 +-
 .../sortingcomponents/merging/method_list.py  |  6 +---
 .../sortingcomponents/merging/tools.py        |  3 +-
 8 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index ae3a5dd295..addbf63aab 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -521,39 +521,40 @@ def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
     might be used for benchmarking meta merging step (see components)
     """
 
-    if sorting_analyzer.get_extension('spike_amplitudes') is None:
+    if sorting_analyzer.get_extension("spike_amplitudes") is None:
         sorting_analyzer.compute("spike_amplitudes")
 
     sa = sorting_analyzer
 
     from spikeinterface.core.numpyextractors import NumpySorting
     from spikeinterface.core.template_tools import get_template_extremum_channel
+
     extremum_channel_inds = get_template_extremum_channel(sa, outputs="index")
     spikes = sa.sorting.to_spike_vector(extremum_channel_inds=extremum_channel_inds)
     new_spikes = spikes.copy()
-    amplitudes = sa.get_extension('spike_amplitudes').get_data()
-    nb_splits = int(splitting_probability*len(sa.sorting.unit_ids))
+    amplitudes = sa.get_extension("spike_amplitudes").get_data()
+    nb_splits = int(splitting_probability * len(sa.sorting.unit_ids))
     to_split_ids = np.random.choice(sa.sorting.unit_ids, nb_splits, replace=False)
-    max_index = np.max(spikes['unit_index'])
+    max_index = np.max(spikes["unit_index"])
     new_unit_ids = list(sa.sorting.unit_ids.copy())
     splitted_pairs = []
     for unit_id in to_split_ids:
-        ind_mask = spikes['unit_index'] == sa.sorting.id_to_index(unit_id)
+        ind_mask = spikes["unit_index"] == sa.sorting.id_to_index(unit_id)
 
         m = amplitudes[ind_mask].mean()
         s = amplitudes[ind_mask].std()
-        thresh = m + 0.2*s
+        thresh = m + 0.2 * s
 
-        amplitude_mask = (amplitudes > thresh)
+        amplitude_mask = amplitudes > thresh
         mask = ind_mask & amplitude_mask
-        new_spikes['unit_index'][mask] = max_index + 1
+        new_spikes["unit_index"][mask] = max_index + 1
 
         amplitude_mask = (amplitudes > m) * (amplitudes < thresh)
         mask = ind_mask & amplitude_mask
-        new_spikes['unit_index'][mask] = (max_index + 1)*np.random.rand(np.sum(mask)) > 0.5
+        new_spikes["unit_index"][mask] = (max_index + 1) * np.random.rand(np.sum(mask)) > 0.5
         max_index += 1
-        new_unit_ids += [max(new_unit_ids)+1]
+        new_unit_ids += [max(new_unit_ids) + 1]
         splitted_pairs += [(unit_id, new_unit_ids[-1])]
 
     new_sorting = NumpySorting(new_spikes, sampling_frequency=sa.sampling_frequency, unit_ids=new_unit_ids)
-    return new_sorting, splitted_pairs
\ No newline at end of file
+    return new_sorting, splitted_pairs
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index f3a2bbacd8..9f56456aaf 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -26,7 +26,7 @@ def __init__(self, recording, splitted_sorting, params, gt_sorting):
         self.result = {}
 
     def run(self, **job_kwargs):
-        self.result['sorting'] = merge_spikes(
+        self.result["sorting"] = merge_spikes(
             self.recording, self.splitted_sorting, method=self.method, method_kwargs=self.method_kwargs
         )
 
@@ -34,7 +34,7 @@ def compute_result(self, **result_params):
         sorting = self.result["sorting"]
         comp = compare_sorter_to_ground_truth(self.gt_sorting, sorting, exhaustive_gt=True)
         self.result["gt_comparison"] = comp
-        
+
     _run_key_saved = [
         ("sorting", "sorting"),
     ]
@@ -105,4 +105,4 @@ def plot_agreements(self, case_keys=None, figsize=(15, 15)):
     def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
         from spikeinterface.widgets.widget_list import plot_study_unit_counts
 
-        plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
\ No newline at end of file
+        plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index f8ab3b141e..ef6b917e58 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -7,20 +7,19 @@
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
+
 class CircusMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric
     """
 
-    default_params = {
-        'templates' : None
-    }
-    
+    default_params = {"templates": None}
+
     def __init__(self, recording, sorting, kwargs):
         self.default_params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.templates = self.default_params.pop('templates', None)
+        self.templates = self.default_params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -31,9 +30,9 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
         else:
             self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(['random_spikes', 'templates'])
+            self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        
+
     def run(self):
         merges = get_potential_auto_merge(self.analyzer, **self.default_params)
         merges = resolve_merging_graph(self.sorting, merges)
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
index 6efb370b4e..318fae2ee7 100644
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -12,7 +12,7 @@ def compute_presence_distance(analyzer, unit1, unit2, bin_duration_s=2, percenti
     """
     Compute the presence distance between two units.
 
-    The presence distance is defined as the sum of the absolute difference between the sum of 
+    The presence distance is defined as the sum of the absolute difference between the sum of
     the normalized firing profiles of the two units and a constant firing profile.
 
     Parameters
@@ -56,7 +56,7 @@ def compute_presence_distance(analyzer, unit1, unit2, bin_duration_s=2, percenti
         d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / analyzer.get_total_duration()
     else:
         d = np.nan
-    
+
     return d
 
 
@@ -79,7 +79,7 @@ def get_potential_drift_merges(analyzer, similarity_threshold=0.7, presence_dist
     -------
     potential_merges: list
         The list of potential merges
-    
+
     """
     assert analyzer.get_extension("templates") is not None, "The templates extension is required"
     assert analyzer.get_extension("template_similarity") is not None, "The template_similarity extension is required"
@@ -90,7 +90,7 @@ def get_potential_drift_merges(analyzer, similarity_threshold=0.7, presence_dist
     bins = np.arange(0, analyzer.get_num_samples(), bin_size)
 
     for i, unit1 in enumerate(analyzer.unit_ids):
-        for j, unit2 in enumerate(analyzer.unit_ids):    
+        for j, unit2 in enumerate(analyzer.unit_ids):
             if i != j and similarity[i, j] > similarity_threshold:
                 d = compute_presence_distance(analyzer, unit1, unit2, bins=bins)
                 distances[i, j] = d
@@ -106,24 +106,23 @@ def get_potential_drift_merges(analyzer, similarity_threshold=0.7, presence_dist
     return potential_merges
 
 
-
 class DriftMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric
     """
 
     default_params = {
-        'templates' : None,
-        'similarity_threshold' : 0.7, 
-        'presence_distance_threshold' : 0.1, 
-        'bin_duration_s' : 2
+        "templates": None,
+        "similarity_threshold": 0.7,
+        "presence_distance_threshold": 0.1,
+        "bin_duration_s": 2,
     }
-    
+
     def __init__(self, recording, sorting, kwargs):
         self.default_params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.templates = self.default_params.pop('templates', None)
+        self.templates = self.default_params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -134,9 +133,9 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
         else:
             self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(['random_spikes', 'templates'])
+            self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        self.analyzer.compute(['template_similarity'])
+        self.analyzer.compute(["template_similarity"])
 
     def run(self):
         merges = get_potential_drift_merges(self.analyzer, **self.default_params)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 573cd4fff8..223006753a 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -9,8 +9,14 @@
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 
-def aurelien_merge(analyzer, refractory_period, template_threshold: float = 0.12, CC_threshold: float = 0.15,
-                   max_shift: int = 10, max_channels: int = 10) -> list[tuple]:
+def aurelien_merge(
+    analyzer,
+    refractory_period,
+    template_threshold: float = 0.12,
+    CC_threshold: float = 0.15,
+    max_shift: int = 10,
+    max_channels: int = 10,
+) -> list[tuple]:
     """
     Looks at a sorting analyzer, and returns a list of potential pairwise merges.
 
@@ -31,7 +37,7 @@ def aurelien_merge(analyzer, refractory_period, template_threshold: float = 0.12
     max_channels: int
         The maximum number of channels to consider when comparing the templates.
     """
-    
+
     pairs = []
     sorting = analyzer.sorting
     recording = analyzer.recording
@@ -46,14 +52,14 @@ def aurelien_merge(analyzer, refractory_period, template_threshold: float = 0.12
             # Computing template difference
             template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
             template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
-    
+
             best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:10]
-            
+
             max_diff = 1
-            for shift in range(-max_shift, max_shift+1):
+            for shift in range(-max_shift, max_shift + 1):
                 n = len(template1)
-                t1 = template1[max_shift: n-max_shift, best_channel_indices]
-                t2 = template2[max_shift+shift: n-max_shift+shift, best_channel_indices]
+                t1 = template1[max_shift : n - max_shift, best_channel_indices]
+                t2 = template2[max_shift + shift : n - max_shift + shift, best_channel_indices]
                 diff = np.sum(np.abs(t1 - t2)) / np.sum(np.abs(t1) + np.abs(t2))
                 if diff < max_diff:
                     max_diff = diff
@@ -79,16 +85,13 @@ class LussacMerging(BaseMergingEngine):
     Meta merging inspired from the Lussac metric
     """
 
-    default_params = {
-        'templates' : None,
-        'refractory_period' : (0.4, 1.9)
-    }
-    
+    default_params = {"templates": None, "refractory_period": (0.4, 1.9)}
+
     def __init__(self, recording, sorting, kwargs):
         self.default_params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.templates = self.default_params.pop('templates', None)
+        self.templates = self.default_params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -99,9 +102,9 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
         else:
             self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(['random_spikes', 'templates'])
+            self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        
+
     def run(self):
         merges = aurelien_merge(self.analyzer, **self.default_params)
         merges = resolve_merging_graph(self.sorting, merges)
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index c52d0d508b..a80e9014dd 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -3,6 +3,7 @@
 from threadpoolctl import threadpool_limits
 import numpy as np
 
+
 def merge_spikes(
     recording, sorting, method="circus", method_kwargs={}, extra_outputs=False, verbose=False, **job_kwargs
 ):
@@ -54,4 +55,4 @@ def __init__(self, recording, sorting, kwargs):
 
     def run(self):
         # need to be implemented in subclass
-        raise NotImplementedError
\ No newline at end of file
+        raise NotImplementedError
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index 52ab0accf0..cb40984054 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -4,8 +4,4 @@
 from .lussac import LussacMerging
 from .drift import DriftMerging
 
-merging_methods = {
-    "circus" : CircusMerging,
-    "lussac" : LussacMerging,
-    "drift" : DriftMerging
-}
+merging_methods = {"circus": CircusMerging, "lussac": LussacMerging, "drift": DriftMerging}
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
index ba3bb4a033..d8b3a88bdc 100644
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -1,6 +1,7 @@
 import numpy as np
 from spikeinterface.core import NumpySorting
 
+
 def resolve_merging_graph(sorting, potential_merges):
     """
     Function to provide, given a list of potential_merges, a resolved merging
@@ -64,4 +65,4 @@ def apply_merges_to_sorting(sorting, merges, censor_ms=0.4):
             labels_list += [spikes["unit_index"][s0:s1]]
 
     sorting = NumpySorting.from_times_labels(times_list, labels_list, sorting.sampling_frequency)
-    return sorting
\ No newline at end of file
+    return sorting

From 08c5583548a2a978c1cf3eaf1f79a2ad4a5bbafd Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 14:42:31 +0200
Subject: [PATCH 008/164] WIP

---
 src/spikeinterface/generation/drift_tools.py  | 20 ++++++++++
 .../benchmark/benchmark_merging.py            | 25 ++++++++++--
 .../sortingcomponents/merging/lussac.py       | 40 ++++++++++++++-----
 3 files changed, 71 insertions(+), 14 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index ae3a5dd295..6e49d09f21 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -515,6 +515,26 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
+
+def split_sorting_by_time(sorting_analyzer, splitting_probability=0.5):
+    sorting = sorting_analyzer.sorting
+    partial_split_prob = 0.95
+    sorting_split = sorting.select_units(sorting.unit_ids)
+    split_units = []
+    original_units = []
+    nb_splits = int(splitting_probability*len(sorting.unit_ids))
+    to_split_ids = np.random.choice(sorting.unit_ids, nb_splits, replace=False)
+    import spikeinterface.curation as scur
+    for unit in to_split_ids:
+        num_spikes = len(sorting_split.get_unit_spike_train(unit))
+        indices = np.zeros(num_spikes, dtype=int)
+        indices[:num_spikes // 2] = (np.random.rand(num_spikes // 2) < partial_split_prob).astype(int)
+        indices[num_spikes // 2:] = (np.random.rand(num_spikes - num_spikes // 2) < 1 - partial_split_prob).astype(int)
+        sorting_split = scur.split_unit_sorting(sorting_split, split_unit_id=unit, indices_list=indices, properties_policy="remove")
+        split_units.append(sorting_split.unit_ids[-2:])
+        original_units.append(unit)
+    return sorting_split, split_units
+
 def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
     """
     Fonction used to split a sorting based on the amplitudes of the units. This
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index f3a2bbacd8..fa28a53b70 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -6,6 +6,8 @@
 from spikeinterface.widgets import (
     plot_agreement_matrix,
     plot_comparison_collision_by_similarity,
+    plot_amplitudes, 
+    plot_crosscorrelograms
 )
 
 import pylab as plt
@@ -17,11 +19,12 @@
 
 class MergingBenchmark(Benchmark):
 
-    def __init__(self, recording, splitted_sorting, params, gt_sorting):
+    def __init__(self, recording, splitted_sorting, params, gt_sorting, splitted_cells=None):
         self.recording = recording
         self.splitted_sorting = splitted_sorting
         self.method = params["method"]
         self.gt_sorting = gt_sorting
+        self.splitted_cells = splitted_cells
         self.method_kwargs = params["method_kwargs"]
         self.result = {}
 
@@ -94,7 +97,6 @@ def plot_agreements(self, case_keys=None, figsize=(15, 15)):
             case_keys = list(self.cases.keys())
 
         fig, axs = plt.subplots(ncols=len(case_keys), nrows=1, figsize=figsize, squeeze=False)
-
         for count, key in enumerate(case_keys):
             ax = axs[0, count]
             ax.set_title(self.cases[key]["label"])
@@ -105,4 +107,21 @@ def plot_agreements(self, case_keys=None, figsize=(15, 15)):
     def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
         from spikeinterface.widgets.widget_list import plot_study_unit_counts
 
-        plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
\ No newline at end of file
+        plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
+    
+    def get_splitted_pairs(self, case_key):
+        return self.benchmarks[case_key].splitted_cells
+
+    def plot_splitted_amplitudes(self, case_key, pair_index=0):
+        analyzer = self.get_sorting_analyzer(case_key)
+        if analyzer.get_extension('spike_amplitudes') is None:
+            analyzer.compute(['spike_amplitudes'])
+        plot_amplitudes(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
+    
+    def plot_splitted_correlograms(self, case_key, pair_index=0):
+        analyzer = self.get_sorting_analyzer(case_key)
+        if analyzer.get_extension('correlograms') is None:
+            analyzer.compute(['correlograms'])
+        if analyzer.get_extension('template_similarity') is None:
+            analyzer.compute(['template_similarity'])
+        plot_crosscorrelograms(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 573cd4fff8..0469c3ac8f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -9,8 +9,13 @@
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 
-def aurelien_merge(analyzer, refractory_period, template_threshold: float = 0.12, CC_threshold: float = 0.15,
-                   max_shift: int = 10, max_channels: int = 10) -> list[tuple]:
+def aurelien_merge(analyzer, 
+                   refractory_period, 
+                   template_threshold: float = 0.2, 
+                   CC_threshold: float = 0.15,
+                   max_shift: int = 10, 
+                   max_channels: int = 10,
+                   template_metric="cosine") -> list[tuple]:
     """
     Looks at a sorting analyzer, and returns a list of potential pairwise merges.
 
@@ -47,16 +52,29 @@ def aurelien_merge(analyzer, refractory_period, template_threshold: float = 0.12
             template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
             template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
     
-            best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:10]
+            best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:max_channels]
             
-            max_diff = 1
-            for shift in range(-max_shift, max_shift+1):
-                n = len(template1)
-                t1 = template1[max_shift: n-max_shift, best_channel_indices]
-                t2 = template2[max_shift+shift: n-max_shift+shift, best_channel_indices]
-                diff = np.sum(np.abs(t1 - t2)) / np.sum(np.abs(t1) + np.abs(t2))
-                if diff < max_diff:
-                    max_diff = diff
+            if template_metric == "l1":
+                norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
+            elif template_metric == "l2":
+                norm = np.sum(template1**2) + np.sum(template2**2)
+            elif template_metric == "cosine":
+                norm = np.linalg.norm(template1) * np.linalg.norm(template2)
+            
+            all_shift_diff = []
+            n = len(template1)
+            for shift in range(-max_shift, max_shift + 1):
+                temp1 = template1[max_shift : n - max_shift, best_channel_indices]
+                temp2 = template2[max_shift + shift : n - max_shift + shift, best_channel_indices]
+                if template_metric == "l1":
+                    d = np.sum(np.abs(temp1 - temp2)) / norm
+                elif template_metric == "l2":
+                    d = np.linalg.norm(temp1 - temp2) / norm
+                elif template_metric == "cosine":
+                    d = 1 - np.sum(temp1 * temp2) / norm
+                all_shift_diff.append(d)
+
+            max_diff = np.min(all_shift_diff)
 
             if max_diff > template_threshold:
                 continue

From a811f662bb70a6a3d671fbcfb5a7d4944f72ba03 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 30 May 2024 12:43:49 +0000
Subject: [PATCH 009/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/generation/drift_tools.py  | 13 ++++++----
 .../benchmark/benchmark_merging.py            | 20 +++++++-------
 .../sortingcomponents/merging/lussac.py       | 26 +++++++++++--------
 3 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index e7e0ffbba2..11d8d2bfcf 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -515,26 +515,29 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-
 def split_sorting_by_time(sorting_analyzer, splitting_probability=0.5):
     sorting = sorting_analyzer.sorting
     partial_split_prob = 0.95
     sorting_split = sorting.select_units(sorting.unit_ids)
     split_units = []
     original_units = []
-    nb_splits = int(splitting_probability*len(sorting.unit_ids))
+    nb_splits = int(splitting_probability * len(sorting.unit_ids))
     to_split_ids = np.random.choice(sorting.unit_ids, nb_splits, replace=False)
     import spikeinterface.curation as scur
+
     for unit in to_split_ids:
         num_spikes = len(sorting_split.get_unit_spike_train(unit))
         indices = np.zeros(num_spikes, dtype=int)
-        indices[:num_spikes // 2] = (np.random.rand(num_spikes // 2) < partial_split_prob).astype(int)
-        indices[num_spikes // 2:] = (np.random.rand(num_spikes - num_spikes // 2) < 1 - partial_split_prob).astype(int)
-        sorting_split = scur.split_unit_sorting(sorting_split, split_unit_id=unit, indices_list=indices, properties_policy="remove")
+        indices[: num_spikes // 2] = (np.random.rand(num_spikes // 2) < partial_split_prob).astype(int)
+        indices[num_spikes // 2 :] = (np.random.rand(num_spikes - num_spikes // 2) < 1 - partial_split_prob).astype(int)
+        sorting_split = scur.split_unit_sorting(
+            sorting_split, split_unit_id=unit, indices_list=indices, properties_policy="remove"
+        )
         split_units.append(sorting_split.unit_ids[-2:])
         original_units.append(unit)
     return sorting_split, split_units
 
+
 def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
     """
     Fonction used to split a sorting based on the amplitudes of the units. This
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 7c279f7fee..3df13dd8ad 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -6,8 +6,8 @@
 from spikeinterface.widgets import (
     plot_agreement_matrix,
     plot_comparison_collision_by_similarity,
-    plot_amplitudes, 
-    plot_crosscorrelograms
+    plot_amplitudes,
+    plot_crosscorrelograms,
 )
 
 import pylab as plt
@@ -108,20 +108,20 @@ def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
         from spikeinterface.widgets.widget_list import plot_study_unit_counts
 
         plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
-    
+
     def get_splitted_pairs(self, case_key):
         return self.benchmarks[case_key].splitted_cells
 
     def plot_splitted_amplitudes(self, case_key, pair_index=0):
         analyzer = self.get_sorting_analyzer(case_key)
-        if analyzer.get_extension('spike_amplitudes') is None:
-            analyzer.compute(['spike_amplitudes'])
+        if analyzer.get_extension("spike_amplitudes") is None:
+            analyzer.compute(["spike_amplitudes"])
         plot_amplitudes(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
-    
+
     def plot_splitted_correlograms(self, case_key, pair_index=0):
         analyzer = self.get_sorting_analyzer(case_key)
-        if analyzer.get_extension('correlograms') is None:
-            analyzer.compute(['correlograms'])
-        if analyzer.get_extension('template_similarity') is None:
-            analyzer.compute(['template_similarity'])
+        if analyzer.get_extension("correlograms") is None:
+            analyzer.compute(["correlograms"])
+        if analyzer.get_extension("template_similarity") is None:
+            analyzer.compute(["template_similarity"])
         plot_crosscorrelograms(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 468cad3ea6..57cf667dcb 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -9,13 +9,15 @@
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 
-def aurelien_merge(analyzer, 
-                   refractory_period, 
-                   template_threshold: float = 0.2, 
-                   CC_threshold: float = 0.15,
-                   max_shift: int = 10, 
-                   max_channels: int = 10,
-                   template_metric="cosine") -> list[tuple]:
+def aurelien_merge(
+    analyzer,
+    refractory_period,
+    template_threshold: float = 0.2,
+    CC_threshold: float = 0.15,
+    max_shift: int = 10,
+    max_channels: int = 10,
+    template_metric="cosine",
+) -> list[tuple]:
     """
     Looks at a sorting analyzer, and returns a list of potential pairwise merges.
 
@@ -51,16 +53,18 @@ def aurelien_merge(analyzer,
             # Computing template difference
             template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
             template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
-    
-            best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:max_channels]
-            
+
+            best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][
+                :max_channels
+            ]
+
             if template_metric == "l1":
                 norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
             elif template_metric == "l2":
                 norm = np.sum(template1**2) + np.sum(template2**2)
             elif template_metric == "cosine":
                 norm = np.linalg.norm(template1) * np.linalg.norm(template2)
-            
+
             all_shift_diff = []
             n = len(template1)
             for shift in range(-max_shift, max_shift + 1):

From 51517ab550a067b90467762c25e78ffc4adad290 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 15:22:02 +0200
Subject: [PATCH 010/164] WIP

---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 8 +-------
 src/spikeinterface/sortingcomponents/merging/circus.py | 6 +++++-
 src/spikeinterface/sortingcomponents/merging/lussac.py | 6 +++---
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index da2250102c..1f7dad0e0d 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -42,13 +42,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {
-            "minimum_spikes": 10,
-            "corr_diff_thresh": 0.5,
-            "template_metric": "cosine",
-            "censor_correlograms_ms": 0.4,
-            "num_channels": None,
-        },
+        "merging": {"method" : "lussac"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index ef6b917e58..e00c5bcb6c 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -13,7 +13,11 @@ class CircusMerging(BaseMergingEngine):
     Meta merging inspired from the Lussac metric
     """
 
-    default_params = {"templates": None}
+    default_params = {"templates": None, 
+                      "minimum_spikes": 50,
+                      "corr_diff_thresh": 0.5,
+                      "template_metric": "cosine",
+                      "num_channels": None}
 
     def __init__(self, recording, sorting, kwargs):
         self.default_params.update(**kwargs)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 57cf667dcb..37d877fdd4 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -13,7 +13,7 @@ def aurelien_merge(
     analyzer,
     refractory_period,
     template_threshold: float = 0.2,
-    CC_threshold: float = 0.15,
+    CC_threshold: float = 0.1,
     max_shift: int = 10,
     max_channels: int = 10,
     template_metric="cosine",
@@ -86,9 +86,9 @@ def aurelien_merge(
             # Compuyting the cross-contamination difference
             spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
-            CC = utils.estimate_cross_contamination(spike_train1, spike_train2, refractory_period)
+            CC, p_value = utils.estimate_cross_contamination(spike_train1, spike_train2, refractory_period, limit=CC_threshold)
 
-            if CC > CC_threshold:
+            if p_value < 0.05:
                 continue
 
             pairs.append((unit_id1, unit_id2))

From 2fa8ace066b253be0dcbb06369116184675c21a4 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 15:46:35 +0200
Subject: [PATCH 011/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 37d877fdd4..5447549901 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,7 +12,7 @@
 def aurelien_merge(
     analyzer,
     refractory_period,
-    template_threshold: float = 0.2,
+    template_threshold: float = 0.25,
     CC_threshold: float = 0.1,
     max_shift: int = 10,
     max_channels: int = 10,

From fce51e8257e83a17929e8f3f4a6f4b8d4a266078 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 30 May 2024 13:47:45 +0000
Subject: [PATCH 012/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sorters/internal/spyking_circus2.py              |  2 +-
 .../sortingcomponents/merging/circus.py              | 12 +++++++-----
 .../sortingcomponents/merging/lussac.py              |  4 +++-
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 1f7dad0e0d..341108d96b 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -42,7 +42,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {"method" : "lussac"},
+        "merging": {"method": "lussac"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index e00c5bcb6c..a643377425 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -13,11 +13,13 @@ class CircusMerging(BaseMergingEngine):
     Meta merging inspired from the Lussac metric
     """
 
-    default_params = {"templates": None, 
-                      "minimum_spikes": 50,
-                      "corr_diff_thresh": 0.5,
-                      "template_metric": "cosine",
-                      "num_channels": None}
+    default_params = {
+        "templates": None,
+        "minimum_spikes": 50,
+        "corr_diff_thresh": 0.5,
+        "template_metric": "cosine",
+        "num_channels": None,
+    }
 
     def __init__(self, recording, sorting, kwargs):
         self.default_params.update(**kwargs)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 5447549901..bb6f1b5b17 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -86,7 +86,9 @@ def aurelien_merge(
             # Compuyting the cross-contamination difference
             spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
-            CC, p_value = utils.estimate_cross_contamination(spike_train1, spike_train2, refractory_period, limit=CC_threshold)
+            CC, p_value = utils.estimate_cross_contamination(
+                spike_train1, spike_train2, refractory_period, limit=CC_threshold
+            )
 
             if p_value < 0.05:
                 continue

From 1693e07dce76acaab684d4cca961d22acebc14e2 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 16:35:35 +0200
Subject: [PATCH 013/164] WIP

---
 src/spikeinterface/generation/drift_tools.py             | 3 +--
 src/spikeinterface/sorters/internal/spyking_circus2.py   | 4 ++--
 .../sortingcomponents/benchmark/benchmark_merging.py     | 5 +++--
 src/spikeinterface/sortingcomponents/merging/circus.py   | 7 +++++--
 src/spikeinterface/sortingcomponents/merging/drift.py    | 7 +++++--
 src/spikeinterface/sortingcomponents/merging/lussac.py   | 9 ++++++---
 src/spikeinterface/sortingcomponents/merging/main.py     | 8 +-------
 7 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index 11d8d2bfcf..e4e119b0d4 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -515,9 +515,8 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-def split_sorting_by_time(sorting_analyzer, splitting_probability=0.5):
+def split_sorting_by_time(sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
     sorting = sorting_analyzer.sorting
-    partial_split_prob = 0.95
     sorting_split = sorting.select_units(sorting.unit_ids)
     split_units = []
     original_units = []
diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 1f7dad0e0d..dbac970559 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -42,7 +42,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {"method" : "lussac"},
+        "merging": {"method" : "circus"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
@@ -164,7 +164,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         nbefore = int(ms_before * fs / 1000.0)
         nafter = int(ms_after * fs / 1000.0)
 
-        peaks = detect_peaks(recording_w, "locally_exclusive", **detection_params)
+        peaks = detect_peaks(recording_w, "locally_exclusive", **detection_params)  
 
         if params["matched_filtering"]:
             prototype = get_prototype_spike(recording_w, peaks, ms_before, ms_after, **job_kwargs)
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 3df13dd8ad..d498e92d9f 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -29,8 +29,8 @@ def __init__(self, recording, splitted_sorting, params, gt_sorting, splitted_cel
         self.result = {}
 
     def run(self, **job_kwargs):
-        self.result["sorting"] = merge_spikes(
-            self.recording, self.splitted_sorting, method=self.method, method_kwargs=self.method_kwargs
+        self.result["sorting"], self.result['merges'] = merge_spikes(
+            self.recording, self.splitted_sorting, method=self.method, method_kwargs=self.method_kwargs, extra_outputs=True
         )
 
     def compute_result(self, **result_params):
@@ -40,6 +40,7 @@ def compute_result(self, **result_params):
 
     _run_key_saved = [
         ("sorting", "sorting"),
+        ("merges", "pickle")
     ]
     _result_key_saved = [("gt_comparison", "pickle")]
 
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index e00c5bcb6c..5d356df014 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -37,8 +37,11 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-    def run(self):
+    def run(self, extra_outputs=False):
         merges = get_potential_auto_merge(self.analyzer, **self.default_params)
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
-        return sorting
+        if extra_outputs:
+            return sorting, merges
+        else:
+            return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
index 318fae2ee7..6ab0d24ee8 100644
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -137,8 +137,11 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
         self.analyzer.compute(["template_similarity"])
 
-    def run(self):
+    def run(self, extra_outputs=False):
         merges = get_potential_drift_merges(self.analyzer, **self.default_params)
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
-        return sorting
+        if extra_outputs:
+            return sorting, merges
+        else:
+            return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 5447549901..a7e450a02f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -16,7 +16,7 @@ def aurelien_merge(
     CC_threshold: float = 0.1,
     max_shift: int = 10,
     max_channels: int = 10,
-    template_metric="cosine",
+    template_metric="l1",
 ) -> list[tuple]:
     """
     Looks at a sorting analyzer, and returns a list of potential pairwise merges.
@@ -121,8 +121,11 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-    def run(self):
+    def run(self, extra_outputs=False):
         merges = aurelien_merge(self.analyzer, **self.default_params)
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
-        return sorting
+        if extra_outputs:
+            return sorting, merges
+        else:
+            return sorting
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index a80e9014dd..02ae2a4884 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -36,13 +36,7 @@ def merge_spikes(
 
     method_class = merging_methods[method]
     method_instance = method_class(recording, sorting, method_kwargs)
-    new_sorting = method_instance.run()
-
-    if extra_outputs:
-        return new_sorting, method_kwargs
-    else:
-        return new_sorting
-
+    return method_instance.run(extra_outputs=extra_outputs)
 
 # generic class for template engine
 class BaseMergingEngine:

From f67b05bf236a21f004859a77d7adbf3988ecb8ae Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 30 May 2024 14:36:34 +0000
Subject: [PATCH 014/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sorters/internal/spyking_circus2.py             |  4 ++--
 .../benchmark/benchmark_merging.py                  | 13 +++++++------
 .../sortingcomponents/merging/lussac.py             |  2 +-
 .../sortingcomponents/merging/main.py               |  1 +
 4 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index dbac970559..5c105075e1 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -42,7 +42,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {"method" : "circus"},
+        "merging": {"method": "circus"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
@@ -164,7 +164,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         nbefore = int(ms_before * fs / 1000.0)
         nafter = int(ms_after * fs / 1000.0)
 
-        peaks = detect_peaks(recording_w, "locally_exclusive", **detection_params)  
+        peaks = detect_peaks(recording_w, "locally_exclusive", **detection_params)
 
         if params["matched_filtering"]:
             prototype = get_prototype_spike(recording_w, peaks, ms_before, ms_after, **job_kwargs)
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index d498e92d9f..e93ad56bef 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -29,8 +29,12 @@ def __init__(self, recording, splitted_sorting, params, gt_sorting, splitted_cel
         self.result = {}
 
     def run(self, **job_kwargs):
-        self.result["sorting"], self.result['merges'] = merge_spikes(
-            self.recording, self.splitted_sorting, method=self.method, method_kwargs=self.method_kwargs, extra_outputs=True
+        self.result["sorting"], self.result["merges"] = merge_spikes(
+            self.recording,
+            self.splitted_sorting,
+            method=self.method,
+            method_kwargs=self.method_kwargs,
+            extra_outputs=True,
         )
 
     def compute_result(self, **result_params):
@@ -38,10 +42,7 @@ def compute_result(self, **result_params):
         comp = compare_sorter_to_ground_truth(self.gt_sorting, sorting, exhaustive_gt=True)
         self.result["gt_comparison"] = comp
 
-    _run_key_saved = [
-        ("sorting", "sorting"),
-        ("merges", "pickle")
-    ]
+    _run_key_saved = [("sorting", "sorting"), ("merges", "pickle")]
     _result_key_saved = [("gt_comparison", "pickle")]
 
 
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 6289540ea0..62303c4965 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -130,4 +130,4 @@ def run(self, extra_outputs=False):
         if extra_outputs:
             return sorting, merges
         else:
-            return sorting
\ No newline at end of file
+            return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index 02ae2a4884..c34a72a45b 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -38,6 +38,7 @@ def merge_spikes(
     method_instance = method_class(recording, sorting, method_kwargs)
     return method_instance.run(extra_outputs=extra_outputs)
 
+
 # generic class for template engine
 class BaseMergingEngine:
     default_params = {}

From 0c2b50250c6946dee49eb5f25112725c528c2323 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 30 May 2024 17:48:31 +0200
Subject: [PATCH 015/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 1 +
 src/spikeinterface/sortingcomponents/merging/lussac.py | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 878ae2e02f..5b09557a4a 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -19,6 +19,7 @@ class CircusMerging(BaseMergingEngine):
         "corr_diff_thresh": 0.5,
         "template_metric": "cosine",
         "num_channels": None,
+        "num_shift" : 5
     }
 
     def __init__(self, recording, sorting, kwargs):
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 6289540ea0..d8f2c3ab0f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,7 +12,7 @@
 def aurelien_merge(
     analyzer,
     refractory_period,
-    template_threshold: float = 0.25,
+    template_threshold: float = 0.2,
     CC_threshold: float = 0.1,
     max_shift: int = 10,
     max_channels: int = 10,
@@ -90,7 +90,7 @@ def aurelien_merge(
                 spike_train1, spike_train2, refractory_period, limit=CC_threshold
             )
 
-            if p_value < 0.05:
+            if p_value < 0.2:
                 continue
 
             pairs.append((unit_id1, unit_id2))

From 6cdddb738f624f742a6c49bd87d2be01c1938d2c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 30 May 2024 15:49:02 +0000
Subject: [PATCH 016/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 5b09557a4a..e2d0417654 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -19,7 +19,7 @@ class CircusMerging(BaseMergingEngine):
         "corr_diff_thresh": 0.5,
         "template_metric": "cosine",
         "num_channels": None,
-        "num_shift" : 5
+        "num_shift": 5,
     }
 
     def __init__(self, recording, sorting, kwargs):

From 5130db653b0c7533006cffe6ecc79446fdb2b948 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 08:11:47 +0200
Subject: [PATCH 017/164] WIP

---
 .../sortingcomponents/benchmark/tests/test_benchmark_merging.py   | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
new file mode 100644
index 0000000000..e69de29bb2

From 50135daf571328ed2ee2f28836d7fc3367f5ccbf Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 10:07:20 +0200
Subject: [PATCH 018/164] More plots

---
 .../benchmark/benchmark_merging.py            |  8 +-
 .../benchmark/tests/test_benchmark_merging.py | 81 +++++++++++++++++++
 .../sortingcomponents/merging/lussac.py       |  6 +-
 .../sortingcomponents/merging/method_list.py  | 18 ++++-
 4 files changed, 108 insertions(+), 5 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index e93ad56bef..8a767103a8 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -5,7 +5,7 @@
 from spikeinterface.comparison import CollisionGTComparison, compare_sorter_to_ground_truth
 from spikeinterface.widgets import (
     plot_agreement_matrix,
-    plot_comparison_collision_by_similarity,
+    plot_unit_templates,
     plot_amplitudes,
     plot_crosscorrelograms,
 )
@@ -127,3 +127,9 @@ def plot_splitted_correlograms(self, case_key, pair_index=0):
         if analyzer.get_extension("template_similarity") is None:
             analyzer.compute(["template_similarity"])
         plot_crosscorrelograms(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
+    
+    def plot_splitted_templates(self, case_key, pair_index=0):
+        analyzer = self.get_sorting_analyzer(case_key)
+        if analyzer.get_extension("spike_amplitudes") is None:
+            analyzer.compute(["spike_amplitudes"])
+        plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index e69de29bb2..ce979491aa 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -0,0 +1,81 @@
+import pytest
+import pandas as pd
+from pathlib import Path
+import matplotlib.pyplot as plt
+import numpy as np
+
+import shutil
+
+from spikeinterface.sortingcomponents.benchmark.tests.common_benchmark_testing import make_dataset, cache_folder
+from spikeinterface.sortingcomponents.benchmark.benchmark_merging import MergingStudy
+from spikeinterface.core.template_tools import get_template_extremum_channel
+
+
+@pytest.mark.skip()
+def test_benchmark_clustering():
+
+    job_kwargs = dict(n_jobs=0.8, chunk_duration="1s")
+
+    recording, gt_sorting, gt_analyzer = make_dataset()
+
+    num_spikes = gt_sorting.to_spike_vector().size
+    spike_indices = np.arange(0, num_spikes, 5)
+
+    # create study
+    study_folder = cache_folder / "study_clustering"
+    # datasets = {"toy": (recording, gt_sorting)}
+    datasets = {"toy": gt_analyzer}
+
+    peaks = {}
+    for dataset, gt_analyzer in datasets.items():
+
+        # recording, gt_sorting = datasets[dataset]
+
+        # 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")
+        spikes = gt_analyzer.sorting.to_spike_vector(extremum_channel_inds=extremum_channel_inds)
+        peaks[dataset] = spikes
+
+    cases = {}
+    for method in ["circus", "lussac"]:
+        cases[method] = {
+            "label": f"{method} on toy",
+            "dataset": "toy",
+            "init_kwargs": {"indices": spike_indices, "peaks": peaks["toy"]},
+            "params": {"method": method, "method_kwargs": {}},
+        }
+
+    if study_folder.exists():
+        shutil.rmtree(study_folder)
+    study = ClusteringStudy.create(study_folder, datasets=datasets, cases=cases)
+    print(study)
+
+    # this study needs analyzer
+    # study.create_sorting_analyzer_gt(**job_kwargs)
+    study.compute_metrics()
+
+    study = ClusteringStudy(study_folder)
+
+    # run and result
+    study.run(**job_kwargs)
+    study.compute_results()
+
+    # load study to check persistency
+    study = ClusteringStudy(study_folder)
+    print(study)
+
+    # plots
+    study.plot_performances_vs_snr()
+    study.plot_agreements()
+    study.plot_comparison_clustering()
+    study.plot_error_metrics()
+    study.plot_metrics_vs_snr()
+    study.plot_run_times()
+    study.plot_metrics_vs_snr("cosine")
+    study.homogeneity_score(ignore_noise=False)
+    plt.show()
+
+
+if __name__ == "__main__":
+    test_benchmark_clustering()
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 60cce863e2..28e510e1d6 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -1,6 +1,10 @@
 from __future__ import annotations
 import numpy as np
-import lussac.utils as utils
+try:
+    import lussac.utils as utils
+    HAVE_LUSSAC = True
+except Exception:
+    HAVE_LUSSAC = False
 
 from .main import BaseMergingEngine
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index cb40984054..03c6e26c06 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -1,7 +1,19 @@
 from __future__ import annotations
-
 from .circus import CircusMerging
-from .lussac import LussacMerging
 from .drift import DriftMerging
 
-merging_methods = {"circus": CircusMerging, "lussac": LussacMerging, "drift": DriftMerging}
+
+merging_methods = {"circus": CircusMerging, "drift": DriftMerging}
+
+
+try:
+    import lussac.utils as utils
+    HAVE_LUSSAC = True
+except Exception:
+    HAVE_LUSSAC = False
+
+if HAVE_LUSSAC:
+    from .lussac import LussacMerging
+    merging_methods = {"lussac": LussacMerging}
+
+

From 75963a40b1ac5d6ca9d09d534a7f6d78b4d70e37 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 May 2024 08:07:43 +0000
Subject: [PATCH 019/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sortingcomponents/benchmark/benchmark_merging.py          | 4 ++--
 src/spikeinterface/sortingcomponents/merging/lussac.py        | 2 ++
 src/spikeinterface/sortingcomponents/merging/method_list.py   | 4 ++--
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 8a767103a8..3a320f136c 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -127,9 +127,9 @@ def plot_splitted_correlograms(self, case_key, pair_index=0):
         if analyzer.get_extension("template_similarity") is None:
             analyzer.compute(["template_similarity"])
         plot_crosscorrelograms(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
-    
+
     def plot_splitted_templates(self, case_key, pair_index=0):
         analyzer = self.get_sorting_analyzer(case_key)
         if analyzer.get_extension("spike_amplitudes") is None:
             analyzer.compute(["spike_amplitudes"])
-        plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
\ No newline at end of file
+        plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 28e510e1d6..aaad290938 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -1,7 +1,9 @@
 from __future__ import annotations
 import numpy as np
+
 try:
     import lussac.utils as utils
+
     HAVE_LUSSAC = True
 except Exception:
     HAVE_LUSSAC = False
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index 03c6e26c06..b16324d641 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -8,12 +8,12 @@
 
 try:
     import lussac.utils as utils
+
     HAVE_LUSSAC = True
 except Exception:
     HAVE_LUSSAC = False
 
 if HAVE_LUSSAC:
     from .lussac import LussacMerging
-    merging_methods = {"lussac": LussacMerging}
-
 
+    merging_methods = {"lussac": LussacMerging}

From 8f7e2a02dd3c368a28eb9faef4a6b00b0755f732 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 10:22:18 +0200
Subject: [PATCH 020/164] WIP

---
 .../benchmark/tests/test_benchmark_merging.py | 43 +++++++------------
 1 file changed, 16 insertions(+), 27 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index ce979491aa..ec7c4a3b52 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -8,7 +8,7 @@
 
 from spikeinterface.sortingcomponents.benchmark.tests.common_benchmark_testing import make_dataset, cache_folder
 from spikeinterface.sortingcomponents.benchmark.benchmark_merging import MergingStudy
-from spikeinterface.core.template_tools import get_template_extremum_channel
+from spikeinterface.generation.drift_tools import split_sorting_by_amplitudes
 
 
 @pytest.mark.skip()
@@ -18,64 +18,53 @@ def test_benchmark_clustering():
 
     recording, gt_sorting, gt_analyzer = make_dataset()
 
-    num_spikes = gt_sorting.to_spike_vector().size
-    spike_indices = np.arange(0, num_spikes, 5)
-
     # create study
     study_folder = cache_folder / "study_clustering"
     # datasets = {"toy": (recording, gt_sorting)}
     datasets = {"toy": gt_analyzer}
 
-    peaks = {}
-    for dataset, gt_analyzer in datasets.items():
-
-        # recording, gt_sorting = datasets[dataset]
-
-        # 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")
-        spikes = gt_analyzer.sorting.to_spike_vector(extremum_channel_inds=extremum_channel_inds)
-        peaks[dataset] = spikes
+    gt_analyzer.compute(['random_spikes', 'templates', 'spike_amplitudes'])
+    new_sorting_amp, splitted_cells_amp = split_sorting_by_amplitudes(gt_analyzer)
 
     cases = {}
     for method in ["circus", "lussac"]:
         cases[method] = {
             "label": f"{method} on toy",
             "dataset": "toy",
-            "init_kwargs": {"indices": spike_indices, "peaks": peaks["toy"]},
-            "params": {"method": method, "method_kwargs": {}},
+            "init_kwargs": {"gt_sorting": gt_sorting, "splitted_cells": splitted_cells_amp},
+            "params": {"method": method, "splitted_sorting" : new_sorting_amp, "method_kwargs": {}},
         }
 
     if study_folder.exists():
         shutil.rmtree(study_folder)
-    study = ClusteringStudy.create(study_folder, datasets=datasets, cases=cases)
+    study = MergingStudy.create(study_folder, datasets=datasets, cases=cases)
     print(study)
 
     # this study needs analyzer
     # study.create_sorting_analyzer_gt(**job_kwargs)
     study.compute_metrics()
 
-    study = ClusteringStudy(study_folder)
+    study = MergingStudy(study_folder)
 
     # run and result
     study.run(**job_kwargs)
     study.compute_results()
 
     # load study to check persistency
-    study = ClusteringStudy(study_folder)
+    study = MergingStudy(study_folder)
     print(study)
 
     # plots
-    study.plot_performances_vs_snr()
+    # study.plot_performances_vs_snr()
     study.plot_agreements()
-    study.plot_comparison_clustering()
-    study.plot_error_metrics()
-    study.plot_metrics_vs_snr()
-    study.plot_run_times()
-    study.plot_metrics_vs_snr("cosine")
-    study.homogeneity_score(ignore_noise=False)
+    # study.plot_comparison_clustering()
+    # study.plot_error_metrics()
+    # study.plot_metrics_vs_snr()
+    # study.plot_run_times()
+    # study.plot_metrics_vs_snr("cosine")
+    # study.homogeneity_score(ignore_noise=False)
     plt.show()
 
 
 if __name__ == "__main__":
-    test_benchmark_clustering()
+    test_benchmark_merging()

From 7e766b0ba4452cddc857c106407a8aa48c0610bf Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 May 2024 08:23:23 +0000
Subject: [PATCH 021/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../benchmark/tests/test_benchmark_merging.py                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index ec7c4a3b52..4cbdb1beab 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -23,7 +23,7 @@ def test_benchmark_clustering():
     # datasets = {"toy": (recording, gt_sorting)}
     datasets = {"toy": gt_analyzer}
 
-    gt_analyzer.compute(['random_spikes', 'templates', 'spike_amplitudes'])
+    gt_analyzer.compute(["random_spikes", "templates", "spike_amplitudes"])
     new_sorting_amp, splitted_cells_amp = split_sorting_by_amplitudes(gt_analyzer)
 
     cases = {}
@@ -32,7 +32,7 @@ def test_benchmark_clustering():
             "label": f"{method} on toy",
             "dataset": "toy",
             "init_kwargs": {"gt_sorting": gt_sorting, "splitted_cells": splitted_cells_amp},
-            "params": {"method": method, "splitted_sorting" : new_sorting_amp, "method_kwargs": {}},
+            "params": {"method": method, "splitted_sorting": new_sorting_amp, "method_kwargs": {}},
         }
 
     if study_folder.exists():

From fa48c5694b00a2c0a75a095ff7c63dcf253f2def Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 11:36:51 +0200
Subject: [PATCH 022/164] WIP

---
 .../benchmark/benchmark_merging.py            | 55 +++++++++++++++++++
 .../sortingcomponents/merging/drift.py        |  1 -
 .../sortingcomponents/merging/lussac.py       |  1 -
 3 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 3a320f136c..ed8de0734e 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -133,3 +133,58 @@ def plot_splitted_templates(self, case_key, pair_index=0):
         if analyzer.get_extension("spike_amplitudes") is None:
             analyzer.compute(["spike_amplitudes"])
         plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
+
+    def visualize_splits(self, case_key, figsize=(15, 5)):
+        cc_similarities = []
+        from ..merging.drift import compute_presence_distance
+        analyzer = self.get_sorting_analyzer(case_key)
+        if analyzer.get_extension("template_similarity") is None:
+            analyzer.compute(["template_similarity"])
+
+        distances = {}
+        distances['similarity'] = analyzer.get_extension("template_similarity").get_data()
+        sorting  = analyzer.sorting
+        
+        distances['time_distance'] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+        for i, unit1 in enumerate(analyzer.unit_ids):
+            for j, unit2 in enumerate(analyzer.unit_ids):
+                if unit2 <= unit1:
+                    continue
+                d = compute_presence_distance(analyzer, unit1, unit2)
+                distances['time_distance'][i, j] = d
+        
+        import lussac.utils as utils
+        distances['cross_cont'] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+        for i, unit1 in enumerate(analyzer.unit_ids):
+            for j, unit2 in enumerate(analyzer.unit_ids):
+                if unit2 <= unit1:
+                    continue
+                spike_train1 = np.array(sorting.get_unit_spike_train(unit1))
+                spike_train2 = np.array(sorting.get_unit_spike_train(unit2))
+                distances['cross_cont'][i, j], _ = utils.estimate_cross_contamination(
+                    spike_train1, spike_train2, (1, 4), limit=0.1
+                )
+                
+        splits = np.array(self.benchmarks[case_key].splitted_cells)
+        src, tgt = splits[:,0], splits[:,1]
+        src = analyzer.sorting.ids_to_indices(src)
+        tgt = analyzer.sorting.ids_to_indices(tgt)
+        import pylab as plt
+        fig, axs = plt.subplots(ncols=2, nrows=2, figsize=figsize, squeeze=True)
+        axs[0, 0].scatter(distances['similarity'].flatten(), distances['time_distance'].flatten(), c='k', alpha=0.25)
+        axs[0, 0].scatter(distances['similarity'][src, tgt], distances['time_distance'][src, tgt], c='r')
+        axs[0, 0].set_xlabel('cc similarity')
+        axs[0, 0].set_ylabel('presence ratio')
+
+        axs[1, 0].scatter(distances['similarity'].flatten(), distances['cross_cont'].flatten(), c='k', alpha=0.25)
+        axs[1, 0].scatter(distances['similarity'][src, tgt], distances['cross_cont'][src, tgt], c='r')
+        axs[1, 0].set_xlabel('cc similarity')
+        axs[1, 0].set_ylabel('cross cont')
+        
+        axs[0, 1].scatter(distances['cross_cont'].flatten(), distances['time_distance'].flatten(), c='k', alpha=0.25)
+        axs[0, 1].scatter(distances['cross_cont'][src, tgt], distances['time_distance'][src, tgt], c='r')
+        axs[0, 1].set_xlabel('cross_cont')
+        axs[0, 1].set_ylabel('presence ratio')
+
+        
+        plt.show()
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
index 6ab0d24ee8..968a7c81d2 100644
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 import numpy as np
-import lussac.utils as utils
 
 from .main import BaseMergingEngine
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index aaad290938..497a80fc9b 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -11,7 +11,6 @@
 from .main import BaseMergingEngine
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 

From bfbea8cdb60451e6a623d0069488a1276590ddfe Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 11:51:17 +0200
Subject: [PATCH 023/164] Getting rid of lussac imports

---
 .../sortingcomponents/merging/lussac.py       | 217 +++++++++++++++++-
 1 file changed, 210 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 497a80fc9b..3d5c6e9934 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -1,18 +1,222 @@
 from __future__ import annotations
 import numpy as np
+import math
 
 try:
-    import lussac.utils as utils
+    import numba
 
-    HAVE_LUSSAC = True
-except Exception:
-    HAVE_LUSSAC = False
+    HAVE_NUMBA = True
+except ImportError:
+    HAVE_NUMBA = False
 
 from .main import BaseMergingEngine
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
+def binom_sf(x: int, n: float, p: float) -> float:
+	"""
+	Computes the survival function (sf = 1 - cdf) of the binomial distribution.
+	From values where the cdf is really close to 1.0, the survival function gives more precise results.
+	Allows for a non-integer n (uses interpolation).
+
+	@param x: int
+		The number of successes.
+	@param n: float
+		The number of trials.
+	@param p: float
+		The probability of success.
+	@return sf: float
+		The survival function of the binomial distribution.
+	"""
+
+    import scipy
+    n_array = np.arange(math.floor(n-2), math.ceil(n+3), 1)
+	n_array = n_array[n_array >= 0]
+
+	res = [scipy.stats.binom.sf(x, n_, p) for n_ in n_array]
+	f = scipy.interpolate.interp1d(n_array, res, kind="quadratic")
+
+	return f(n)
+
+
+@numba.jit((numba.float32, ), nopython=True, nogil=True, cache=True)
+def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
+	"""
+	Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
+
+	@param max_time: float
+		The maximum time between 2 spikes to be considered as a coincidence.
+	@return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
+		The borders and their probabilities.
+	"""
+
+	border_high = math.ceil(max_time)
+	border_low = math.floor(max_time)
+	p_high = .5 * (max_time - border_high + 1) ** 2
+	p_low  = .5 * (1 - (max_time - border_low)**2) + (max_time - border_low)
+
+	if border_low == 0:
+		p_low -= .5 * (-max_time + 1)**2
+
+	return border_low, border_high, p_low, p_high
+
+
+@numba.jit((numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
+def compute_nb_violations(spike_train, max_time) -> float:
+	"""
+	Computes the number of refractory period violations in a spike train.
+
+	@param spike_train: array[int64] (n_spikes)
+		The spike train to compute the number of violations for.
+	@param max_time: float32
+		The maximum time to consider for violations (in number of samples).
+	@return n_violations: float
+		The number of spike pairs that violate the refractory period.
+	"""
+
+	if max_time <= 0.0:
+		return 0.0
+
+	border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
+	n_violations = 0
+	n_violations_low = 0
+	n_violations_high = 0
+
+	for i in range(len(spike_train)-1):
+		for j in range(i+1, len(spike_train)):
+			diff = spike_train[j] - spike_train[i]
+
+			if diff > border_high:
+				break
+			if diff == border_high:
+				n_violations_high += 1
+			elif diff == border_low:
+				n_violations_low += 1
+			else:
+				n_violations += 1
+
+	return n_violations + p_high*n_violations_high + p_low*n_violations_low
+
+
+@numba.jit((numba.int64[:], numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
+def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
+	"""
+	Computes the number of coincident spikes between two spike trains.
+	Spike timings are integers, so their real timing follows a uniform distribution between t - dt/2 and t + dt/2.
+	Under the assumption that the uniform distributions from two spikes are independent, we can compute the probability
+	of those two spikes being closer than the coincidence window:
+	f(x) = 1/2 (x+1)² if -1 <= x <= 0
+	f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
+	where x is the distance between max_time floor/ceil(max_time)
+
+	@param spike_train1: array[int64] (n_spikes1)
+		The spike train of the first unit.
+	@param spike_train2: array[int64] (n_spikes2)
+		The spike train of the second unit.
+	@param max_time: float32
+		The maximum time to consider for coincidence (in number samples).
+	@return n_coincidence: float
+		The number of coincident spikes.
+	"""
+
+	if max_time <= 0:
+		return 0.0
+
+	border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
+	n_coincident = 0
+	n_coincident_low = 0
+	n_coincident_high = 0
+
+	start_j = 0
+	for i in range(len(spike_train1)):
+		for j in range(start_j, len(spike_train2)):
+			diff = spike_train1[i] - spike_train2[j]
+
+			if diff > border_high:
+				start_j += 1
+				continue
+			if diff < -border_high:
+				break
+			if abs(diff) == border_high:
+				n_coincident_high += 1
+			elif abs(diff) == border_low:
+				n_coincident_low += 1
+			else:
+				n_coincident += 1
+
+	return n_coincident + p_high*n_coincident_high + p_low*n_coincident_low
+
+
+def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[float, float]) -> float:
+	"""
+	Estimates the contamination of a spike train by looking at the number of refractory period violations.
+	The spike train is assumed to have spikes coming from a neuron, and noisy spikes that are random and
+	uncorrelated to the neuron. Under this assumption, we can estimate the contamination (i.e. the
+	fraction of noisy spikes to the total number of spikes).
+
+	@param spike_train: np.ndarray
+		The unit's spike train.
+	@param refractory_period: tuple[float, float]
+		The censored and refractory period (t_c, t_r) used (in ms).
+	@return estimated_contamination: float
+		The estimated contamination between 0 and 1.
+	"""
+
+	t_c = refractory_period[0] * 1e-3 * sf
+	t_r = refractory_period[1] * 1e-3 * sf
+	n_v = compute_nb_violations(spike_train.astype(np.int64), t_r)
+
+	N = len(spike_train)
+	D = 1 - n_v * (T - 2*N*t_c) / (N**2 * (t_r - t_c))
+	contamination = 1.0 if D < 0 else 1 - math.sqrt(D)
+
+	return contamination
+
+
+def estimate_cross_contamination(spike_train1: np.ndarray, spike_train2: np.ndarray,
+								 refractory_period: tuple[float, float], limit: float | None = None) -> tuple[float, float] | float:
+	"""
+	Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
+	Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
+
+	@param spike_train1: np.ndarray
+		The spike train of the first unit.
+	@param spike_train2: np.ndarray
+		The spike train of the second unit.
+	@param refractory_period: tuple[float, float]
+		The censored and refractory period (t_c, t_r) used (in ms).
+	@param limit: float | None
+		The higher limit of cross-contamination for the statistical test.
+	@return (estimated_cross_cont, p_value): tuple[float, float] if limit is not None
+			estimated_cross_cont: float if limit is None
+		Returns the estimation of cross-contamination, as well as the p-value of the statistical test if the limit is given.
+	"""
+	spike_train1 = spike_train1.astype(np.int64, copy=False)
+	spike_train2 = spike_train2.astype(np.int64, copy=False)
+
+	N1 = len(spike_train1)
+	N2 = len(spike_train2)
+	C1 = estimate_contamination(spike_train1, refractory_period)
+
+	t_c = refractory_period[0] * 1e-3 * sf
+	t_r = refractory_period[1] * 1e-3 * sf
+	n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(spike_train1, spike_train2, t_c)
+
+	estimation = 1 - ((n_violations * T) / (2*N1*N2 * t_r) - 1) / (C1 - 1) if C1 != 1.0 else -np.inf
+	if limit is None:
+		return estimation
+
+	# n and p for the binomial law for the number of coincidence (under the hypothesis of cross-contamination = limit).
+	n = N1 * N2 * ((1 - C1) * limit + C1)
+	p = 2 * t_r / T
+	p_value = binom_sf(int(n_violations - 1), n, p)
+	if np.isnan(p_value):  # Should be unreachable
+		raise ValueError(f"Could not compute p-value for cross-contamination:\n\tn_violations = {n_violations}\n\tn = {n}\n\tp = {p}")
+
+	return estimation, p_value
+
+
 
 def aurelien_merge(
     analyzer,
@@ -44,11 +248,10 @@ def aurelien_merge(
         The maximum number of channels to consider when comparing the templates.
     """
 
+    assert HAVE_NUMBA, "Numba should be installed"
     pairs = []
     sorting = analyzer.sorting
     recording = analyzer.recording
-    utils.Utils.t_max = recording.get_num_frames()
-    utils.Utils.sampling_frequency = recording.sampling_frequency
 
     for unit_id1 in analyzer.unit_ids:
         for unit_id2 in analyzer.unit_ids:
@@ -91,7 +294,7 @@ def aurelien_merge(
             # Compuyting the cross-contamination difference
             spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
-            CC, p_value = utils.estimate_cross_contamination(
+            CC, p_value = estimate_cross_contamination(
                 spike_train1, spike_train2, refractory_period, limit=CC_threshold
             )
 

From 9ecd2414c21eac2027fad2e2f6c05a798413af09 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 May 2024 09:51:54 +0000
Subject: [PATCH 024/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../benchmark/benchmark_merging.py            | 56 ++++++++++---------
 1 file changed, 29 insertions(+), 27 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index ed8de0734e..1d81281f01 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -137,54 +137,56 @@ def plot_splitted_templates(self, case_key, pair_index=0):
     def visualize_splits(self, case_key, figsize=(15, 5)):
         cc_similarities = []
         from ..merging.drift import compute_presence_distance
+
         analyzer = self.get_sorting_analyzer(case_key)
         if analyzer.get_extension("template_similarity") is None:
             analyzer.compute(["template_similarity"])
 
         distances = {}
-        distances['similarity'] = analyzer.get_extension("template_similarity").get_data()
-        sorting  = analyzer.sorting
-        
-        distances['time_distance'] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+        distances["similarity"] = analyzer.get_extension("template_similarity").get_data()
+        sorting = analyzer.sorting
+
+        distances["time_distance"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
         for i, unit1 in enumerate(analyzer.unit_ids):
             for j, unit2 in enumerate(analyzer.unit_ids):
                 if unit2 <= unit1:
                     continue
                 d = compute_presence_distance(analyzer, unit1, unit2)
-                distances['time_distance'][i, j] = d
-        
+                distances["time_distance"][i, j] = d
+
         import lussac.utils as utils
-        distances['cross_cont'] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+
+        distances["cross_cont"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
         for i, unit1 in enumerate(analyzer.unit_ids):
             for j, unit2 in enumerate(analyzer.unit_ids):
                 if unit2 <= unit1:
                     continue
                 spike_train1 = np.array(sorting.get_unit_spike_train(unit1))
                 spike_train2 = np.array(sorting.get_unit_spike_train(unit2))
-                distances['cross_cont'][i, j], _ = utils.estimate_cross_contamination(
+                distances["cross_cont"][i, j], _ = utils.estimate_cross_contamination(
                     spike_train1, spike_train2, (1, 4), limit=0.1
                 )
-                
+
         splits = np.array(self.benchmarks[case_key].splitted_cells)
-        src, tgt = splits[:,0], splits[:,1]
+        src, tgt = splits[:, 0], splits[:, 1]
         src = analyzer.sorting.ids_to_indices(src)
         tgt = analyzer.sorting.ids_to_indices(tgt)
         import pylab as plt
+
         fig, axs = plt.subplots(ncols=2, nrows=2, figsize=figsize, squeeze=True)
-        axs[0, 0].scatter(distances['similarity'].flatten(), distances['time_distance'].flatten(), c='k', alpha=0.25)
-        axs[0, 0].scatter(distances['similarity'][src, tgt], distances['time_distance'][src, tgt], c='r')
-        axs[0, 0].set_xlabel('cc similarity')
-        axs[0, 0].set_ylabel('presence ratio')
-
-        axs[1, 0].scatter(distances['similarity'].flatten(), distances['cross_cont'].flatten(), c='k', alpha=0.25)
-        axs[1, 0].scatter(distances['similarity'][src, tgt], distances['cross_cont'][src, tgt], c='r')
-        axs[1, 0].set_xlabel('cc similarity')
-        axs[1, 0].set_ylabel('cross cont')
-        
-        axs[0, 1].scatter(distances['cross_cont'].flatten(), distances['time_distance'].flatten(), c='k', alpha=0.25)
-        axs[0, 1].scatter(distances['cross_cont'][src, tgt], distances['time_distance'][src, tgt], c='r')
-        axs[0, 1].set_xlabel('cross_cont')
-        axs[0, 1].set_ylabel('presence ratio')
-
-        
-        plt.show()
\ No newline at end of file
+        axs[0, 0].scatter(distances["similarity"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
+        axs[0, 0].scatter(distances["similarity"][src, tgt], distances["time_distance"][src, tgt], c="r")
+        axs[0, 0].set_xlabel("cc similarity")
+        axs[0, 0].set_ylabel("presence ratio")
+
+        axs[1, 0].scatter(distances["similarity"].flatten(), distances["cross_cont"].flatten(), c="k", alpha=0.25)
+        axs[1, 0].scatter(distances["similarity"][src, tgt], distances["cross_cont"][src, tgt], c="r")
+        axs[1, 0].set_xlabel("cc similarity")
+        axs[1, 0].set_ylabel("cross cont")
+
+        axs[0, 1].scatter(distances["cross_cont"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
+        axs[0, 1].scatter(distances["cross_cont"][src, tgt], distances["time_distance"][src, tgt], c="r")
+        axs[0, 1].set_xlabel("cross_cont")
+        axs[0, 1].set_ylabel("presence ratio")
+
+        plt.show()

From 4fe600b05b918666445a65c0f0af7716c6518b45 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 11:54:54 +0200
Subject: [PATCH 025/164] Spaces and tabs

---
 .../sortingcomponents/merging/lussac.py       | 330 +++++++++---------
 1 file changed, 165 insertions(+), 165 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 3d5c6e9934..dca589ae56 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -15,206 +15,206 @@
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 def binom_sf(x: int, n: float, p: float) -> float:
-	"""
-	Computes the survival function (sf = 1 - cdf) of the binomial distribution.
-	From values where the cdf is really close to 1.0, the survival function gives more precise results.
-	Allows for a non-integer n (uses interpolation).
-
-	@param x: int
-		The number of successes.
-	@param n: float
-		The number of trials.
-	@param p: float
-		The probability of success.
-	@return sf: float
-		The survival function of the binomial distribution.
-	"""
+    """
+    Computes the survival function (sf = 1 - cdf) of the binomial distribution.
+    From values where the cdf is really close to 1.0, the survival function gives more precise results.
+    Allows for a non-integer n (uses interpolation).
+
+    @param x: int
+        The number of successes.
+    @param n: float
+        The number of trials.
+    @param p: float
+        The probability of success.
+    @return sf: float
+        The survival function of the binomial distribution.
+    """
 
     import scipy
     n_array = np.arange(math.floor(n-2), math.ceil(n+3), 1)
-	n_array = n_array[n_array >= 0]
+    n_array = n_array[n_array >= 0]
 
-	res = [scipy.stats.binom.sf(x, n_, p) for n_ in n_array]
-	f = scipy.interpolate.interp1d(n_array, res, kind="quadratic")
+    res = [scipy.stats.binom.sf(x, n_, p) for n_ in n_array]
+    f = scipy.interpolate.interp1d(n_array, res, kind="quadratic")
 
-	return f(n)
+    return f(n)
 
 
 @numba.jit((numba.float32, ), nopython=True, nogil=True, cache=True)
 def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
-	"""
-	Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
+    """
+    Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
 
-	@param max_time: float
-		The maximum time between 2 spikes to be considered as a coincidence.
-	@return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
-		The borders and their probabilities.
-	"""
+    @param max_time: float
+        The maximum time between 2 spikes to be considered as a coincidence.
+    @return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
+        The borders and their probabilities.
+    """
 
-	border_high = math.ceil(max_time)
-	border_low = math.floor(max_time)
-	p_high = .5 * (max_time - border_high + 1) ** 2
-	p_low  = .5 * (1 - (max_time - border_low)**2) + (max_time - border_low)
+    border_high = math.ceil(max_time)
+    border_low = math.floor(max_time)
+    p_high = .5 * (max_time - border_high + 1) ** 2
+    p_low  = .5 * (1 - (max_time - border_low)**2) + (max_time - border_low)
 
-	if border_low == 0:
-		p_low -= .5 * (-max_time + 1)**2
+    if border_low == 0:
+        p_low -= .5 * (-max_time + 1)**2
 
-	return border_low, border_high, p_low, p_high
+    return border_low, border_high, p_low, p_high
 
 
 @numba.jit((numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
 def compute_nb_violations(spike_train, max_time) -> float:
-	"""
-	Computes the number of refractory period violations in a spike train.
-
-	@param spike_train: array[int64] (n_spikes)
-		The spike train to compute the number of violations for.
-	@param max_time: float32
-		The maximum time to consider for violations (in number of samples).
-	@return n_violations: float
-		The number of spike pairs that violate the refractory period.
-	"""
+    """
+    Computes the number of refractory period violations in a spike train.
+
+    @param spike_train: array[int64] (n_spikes)
+        The spike train to compute the number of violations for.
+    @param max_time: float32
+        The maximum time to consider for violations (in number of samples).
+    @return n_violations: float
+        The number of spike pairs that violate the refractory period.
+    """
 
-	if max_time <= 0.0:
-		return 0.0
+    if max_time <= 0.0:
+        return 0.0
 
-	border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
-	n_violations = 0
-	n_violations_low = 0
-	n_violations_high = 0
+    border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
+    n_violations = 0
+    n_violations_low = 0
+    n_violations_high = 0
 
-	for i in range(len(spike_train)-1):
-		for j in range(i+1, len(spike_train)):
-			diff = spike_train[j] - spike_train[i]
+    for i in range(len(spike_train)-1):
+        for j in range(i+1, len(spike_train)):
+            diff = spike_train[j] - spike_train[i]
 
-			if diff > border_high:
-				break
-			if diff == border_high:
-				n_violations_high += 1
-			elif diff == border_low:
-				n_violations_low += 1
-			else:
-				n_violations += 1
+            if diff > border_high:
+                break
+            if diff == border_high:
+                n_violations_high += 1
+            elif diff == border_low:
+                n_violations_low += 1
+            else:
+                n_violations += 1
 
-	return n_violations + p_high*n_violations_high + p_low*n_violations_low
+    return n_violations + p_high*n_violations_high + p_low*n_violations_low
 
 
 @numba.jit((numba.int64[:], numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
 def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
-	"""
-	Computes the number of coincident spikes between two spike trains.
-	Spike timings are integers, so their real timing follows a uniform distribution between t - dt/2 and t + dt/2.
-	Under the assumption that the uniform distributions from two spikes are independent, we can compute the probability
-	of those two spikes being closer than the coincidence window:
-	f(x) = 1/2 (x+1)² if -1 <= x <= 0
-	f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
-	where x is the distance between max_time floor/ceil(max_time)
-
-	@param spike_train1: array[int64] (n_spikes1)
-		The spike train of the first unit.
-	@param spike_train2: array[int64] (n_spikes2)
-		The spike train of the second unit.
-	@param max_time: float32
-		The maximum time to consider for coincidence (in number samples).
-	@return n_coincidence: float
-		The number of coincident spikes.
-	"""
-
-	if max_time <= 0:
-		return 0.0
-
-	border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
-	n_coincident = 0
-	n_coincident_low = 0
-	n_coincident_high = 0
-
-	start_j = 0
-	for i in range(len(spike_train1)):
-		for j in range(start_j, len(spike_train2)):
-			diff = spike_train1[i] - spike_train2[j]
-
-			if diff > border_high:
-				start_j += 1
-				continue
-			if diff < -border_high:
-				break
-			if abs(diff) == border_high:
-				n_coincident_high += 1
-			elif abs(diff) == border_low:
-				n_coincident_low += 1
-			else:
-				n_coincident += 1
-
-	return n_coincident + p_high*n_coincident_high + p_low*n_coincident_low
+    """
+    Computes the number of coincident spikes between two spike trains.
+    Spike timings are integers, so their real timing follows a uniform distribution between t - dt/2 and t + dt/2.
+    Under the assumption that the uniform distributions from two spikes are independent, we can compute the probability
+    of those two spikes being closer than the coincidence window:
+    f(x) = 1/2 (x+1)² if -1 <= x <= 0
+    f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
+    where x is the distance between max_time floor/ceil(max_time)
+
+    @param spike_train1: array[int64] (n_spikes1)
+        The spike train of the first unit.
+    @param spike_train2: array[int64] (n_spikes2)
+        The spike train of the second unit.
+    @param max_time: float32
+        The maximum time to consider for coincidence (in number samples).
+    @return n_coincidence: float
+        The number of coincident spikes.
+    """
 
+    if max_time <= 0:
+        return 0.0
 
-def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[float, float]) -> float:
-	"""
-	Estimates the contamination of a spike train by looking at the number of refractory period violations.
-	The spike train is assumed to have spikes coming from a neuron, and noisy spikes that are random and
-	uncorrelated to the neuron. Under this assumption, we can estimate the contamination (i.e. the
-	fraction of noisy spikes to the total number of spikes).
+    border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
+    n_coincident = 0
+    n_coincident_low = 0
+    n_coincident_high = 0
 
-	@param spike_train: np.ndarray
-		The unit's spike train.
-	@param refractory_period: tuple[float, float]
-		The censored and refractory period (t_c, t_r) used (in ms).
-	@return estimated_contamination: float
-		The estimated contamination between 0 and 1.
-	"""
+    start_j = 0
+    for i in range(len(spike_train1)):
+        for j in range(start_j, len(spike_train2)):
+            diff = spike_train1[i] - spike_train2[j]
 
-	t_c = refractory_period[0] * 1e-3 * sf
-	t_r = refractory_period[1] * 1e-3 * sf
-	n_v = compute_nb_violations(spike_train.astype(np.int64), t_r)
+            if diff > border_high:
+                start_j += 1
+                continue
+            if diff < -border_high:
+                break
+            if abs(diff) == border_high:
+                n_coincident_high += 1
+            elif abs(diff) == border_low:
+                n_coincident_low += 1
+            else:
+                n_coincident += 1
 
-	N = len(spike_train)
-	D = 1 - n_v * (T - 2*N*t_c) / (N**2 * (t_r - t_c))
-	contamination = 1.0 if D < 0 else 1 - math.sqrt(D)
+    return n_coincident + p_high*n_coincident_high + p_low*n_coincident_low
 
-	return contamination
+
+def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[float, float]) -> float:
+    """
+    Estimates the contamination of a spike train by looking at the number of refractory period violations.
+    The spike train is assumed to have spikes coming from a neuron, and noisy spikes that are random and
+    uncorrelated to the neuron. Under this assumption, we can estimate the contamination (i.e. the
+    fraction of noisy spikes to the total number of spikes).
+
+    @param spike_train: np.ndarray
+        The unit's spike train.
+    @param refractory_period: tuple[float, float]
+        The censored and refractory period (t_c, t_r) used (in ms).
+    @return estimated_contamination: float
+        The estimated contamination between 0 and 1.
+    """
+
+    t_c = refractory_period[0] * 1e-3 * sf
+    t_r = refractory_period[1] * 1e-3 * sf
+    n_v = compute_nb_violations(spike_train.astype(np.int64), t_r)
+
+    N = len(spike_train)
+    D = 1 - n_v * (T - 2*N*t_c) / (N**2 * (t_r - t_c))
+    contamination = 1.0 if D < 0 else 1 - math.sqrt(D)
+
+    return contamination
 
 
 def estimate_cross_contamination(spike_train1: np.ndarray, spike_train2: np.ndarray,
-								 refractory_period: tuple[float, float], limit: float | None = None) -> tuple[float, float] | float:
-	"""
-	Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
-	Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
-
-	@param spike_train1: np.ndarray
-		The spike train of the first unit.
-	@param spike_train2: np.ndarray
-		The spike train of the second unit.
-	@param refractory_period: tuple[float, float]
-		The censored and refractory period (t_c, t_r) used (in ms).
-	@param limit: float | None
-		The higher limit of cross-contamination for the statistical test.
-	@return (estimated_cross_cont, p_value): tuple[float, float] if limit is not None
-			estimated_cross_cont: float if limit is None
-		Returns the estimation of cross-contamination, as well as the p-value of the statistical test if the limit is given.
-	"""
-	spike_train1 = spike_train1.astype(np.int64, copy=False)
-	spike_train2 = spike_train2.astype(np.int64, copy=False)
-
-	N1 = len(spike_train1)
-	N2 = len(spike_train2)
-	C1 = estimate_contamination(spike_train1, refractory_period)
-
-	t_c = refractory_period[0] * 1e-3 * sf
-	t_r = refractory_period[1] * 1e-3 * sf
-	n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(spike_train1, spike_train2, t_c)
-
-	estimation = 1 - ((n_violations * T) / (2*N1*N2 * t_r) - 1) / (C1 - 1) if C1 != 1.0 else -np.inf
-	if limit is None:
-		return estimation
-
-	# n and p for the binomial law for the number of coincidence (under the hypothesis of cross-contamination = limit).
-	n = N1 * N2 * ((1 - C1) * limit + C1)
-	p = 2 * t_r / T
-	p_value = binom_sf(int(n_violations - 1), n, p)
-	if np.isnan(p_value):  # Should be unreachable
-		raise ValueError(f"Could not compute p-value for cross-contamination:\n\tn_violations = {n_violations}\n\tn = {n}\n\tp = {p}")
-
-	return estimation, p_value
+                                 refractory_period: tuple[float, float], limit: float | None = None) -> tuple[float, float] | float:
+    """
+    Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
+    Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
+
+    @param spike_train1: np.ndarray
+        The spike train of the first unit.
+    @param spike_train2: np.ndarray
+        The spike train of the second unit.
+    @param refractory_period: tuple[float, float]
+        The censored and refractory period (t_c, t_r) used (in ms).
+    @param limit: float | None
+        The higher limit of cross-contamination for the statistical test.
+    @return (estimated_cross_cont, p_value): tuple[float, float] if limit is not None
+            estimated_cross_cont: float if limit is None
+        Returns the estimation of cross-contamination, as well as the p-value of the statistical test if the limit is given.
+    """
+    spike_train1 = spike_train1.astype(np.int64, copy=False)
+    spike_train2 = spike_train2.astype(np.int64, copy=False)
+
+    N1 = len(spike_train1)
+    N2 = len(spike_train2)
+    C1 = estimate_contamination(spike_train1, refractory_period)
+
+    t_c = refractory_period[0] * 1e-3 * sf
+    t_r = refractory_period[1] * 1e-3 * sf
+    n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(spike_train1, spike_train2, t_c)
+
+    estimation = 1 - ((n_violations * T) / (2*N1*N2 * t_r) - 1) / (C1 - 1) if C1 != 1.0 else -np.inf
+    if limit is None:
+        return estimation
+
+    # n and p for the binomial law for the number of coincidence (under the hypothesis of cross-contamination = limit).
+    n = N1 * N2 * ((1 - C1) * limit + C1)
+    p = 2 * t_r / T
+    p_value = binom_sf(int(n_violations - 1), n, p)
+    if np.isnan(p_value):  # Should be unreachable
+        raise ValueError(f"Could not compute p-value for cross-contamination:\n\tn_violations = {n_violations}\n\tn = {n}\n\tp = {p}")
+
+    return estimation, p_value
 
 
 

From 96be6c8840bb84d396c4bd79702a46aacb7b9147 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 May 2024 09:55:55 +0000
Subject: [PATCH 026/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sortingcomponents/merging/lussac.py       | 41 +++++++++++--------
 1 file changed, 25 insertions(+), 16 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index dca589ae56..a333af7812 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -14,6 +14,7 @@
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
+
 def binom_sf(x: int, n: float, p: float) -> float:
     """
     Computes the survival function (sf = 1 - cdf) of the binomial distribution.
@@ -31,7 +32,8 @@ def binom_sf(x: int, n: float, p: float) -> float:
     """
 
     import scipy
-    n_array = np.arange(math.floor(n-2), math.ceil(n+3), 1)
+
+    n_array = np.arange(math.floor(n - 2), math.ceil(n + 3), 1)
     n_array = n_array[n_array >= 0]
 
     res = [scipy.stats.binom.sf(x, n_, p) for n_ in n_array]
@@ -40,7 +42,7 @@ def binom_sf(x: int, n: float, p: float) -> float:
     return f(n)
 
 
-@numba.jit((numba.float32, ), nopython=True, nogil=True, cache=True)
+@numba.jit((numba.float32,), nopython=True, nogil=True, cache=True)
 def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
     """
     Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
@@ -53,11 +55,11 @@ def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
 
     border_high = math.ceil(max_time)
     border_low = math.floor(max_time)
-    p_high = .5 * (max_time - border_high + 1) ** 2
-    p_low  = .5 * (1 - (max_time - border_low)**2) + (max_time - border_low)
+    p_high = 0.5 * (max_time - border_high + 1) ** 2
+    p_low = 0.5 * (1 - (max_time - border_low) ** 2) + (max_time - border_low)
 
     if border_low == 0:
-        p_low -= .5 * (-max_time + 1)**2
+        p_low -= 0.5 * (-max_time + 1) ** 2
 
     return border_low, border_high, p_low, p_high
 
@@ -83,8 +85,8 @@ def compute_nb_violations(spike_train, max_time) -> float:
     n_violations_low = 0
     n_violations_high = 0
 
-    for i in range(len(spike_train)-1):
-        for j in range(i+1, len(spike_train)):
+    for i in range(len(spike_train) - 1):
+        for j in range(i + 1, len(spike_train)):
             diff = spike_train[j] - spike_train[i]
 
             if diff > border_high:
@@ -96,7 +98,7 @@ def compute_nb_violations(spike_train, max_time) -> float:
             else:
                 n_violations += 1
 
-    return n_violations + p_high*n_violations_high + p_low*n_violations_low
+    return n_violations + p_high * n_violations_high + p_low * n_violations_low
 
 
 @numba.jit((numba.int64[:], numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
@@ -145,7 +147,7 @@ def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
             else:
                 n_coincident += 1
 
-    return n_coincident + p_high*n_coincident_high + p_low*n_coincident_low
+    return n_coincident + p_high * n_coincident_high + p_low * n_coincident_low
 
 
 def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[float, float]) -> float:
@@ -168,14 +170,18 @@ def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[flo
     n_v = compute_nb_violations(spike_train.astype(np.int64), t_r)
 
     N = len(spike_train)
-    D = 1 - n_v * (T - 2*N*t_c) / (N**2 * (t_r - t_c))
+    D = 1 - n_v * (T - 2 * N * t_c) / (N**2 * (t_r - t_c))
     contamination = 1.0 if D < 0 else 1 - math.sqrt(D)
 
     return contamination
 
 
-def estimate_cross_contamination(spike_train1: np.ndarray, spike_train2: np.ndarray,
-                                 refractory_period: tuple[float, float], limit: float | None = None) -> tuple[float, float] | float:
+def estimate_cross_contamination(
+    spike_train1: np.ndarray,
+    spike_train2: np.ndarray,
+    refractory_period: tuple[float, float],
+    limit: float | None = None,
+) -> tuple[float, float] | float:
     """
     Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
     Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
@@ -201,9 +207,11 @@ def estimate_cross_contamination(spike_train1: np.ndarray, spike_train2: np.ndar
 
     t_c = refractory_period[0] * 1e-3 * sf
     t_r = refractory_period[1] * 1e-3 * sf
-    n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(spike_train1, spike_train2, t_c)
+    n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(
+        spike_train1, spike_train2, t_c
+    )
 
-    estimation = 1 - ((n_violations * T) / (2*N1*N2 * t_r) - 1) / (C1 - 1) if C1 != 1.0 else -np.inf
+    estimation = 1 - ((n_violations * T) / (2 * N1 * N2 * t_r) - 1) / (C1 - 1) if C1 != 1.0 else -np.inf
     if limit is None:
         return estimation
 
@@ -212,12 +220,13 @@ def estimate_cross_contamination(spike_train1: np.ndarray, spike_train2: np.ndar
     p = 2 * t_r / T
     p_value = binom_sf(int(n_violations - 1), n, p)
     if np.isnan(p_value):  # Should be unreachable
-        raise ValueError(f"Could not compute p-value for cross-contamination:\n\tn_violations = {n_violations}\n\tn = {n}\n\tp = {p}")
+        raise ValueError(
+            f"Could not compute p-value for cross-contamination:\n\tn_violations = {n_violations}\n\tn = {n}\n\tp = {p}"
+        )
 
     return estimation, p_value
 
 
-
 def aurelien_merge(
     analyzer,
     refractory_period,

From 48329ebdb8e91ef525d48d5bd3e1c7e4337dd4ab Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 11:56:34 +0200
Subject: [PATCH 027/164] Removing lussac imports

---
 .../sortingcomponents/merging/method_list.py    | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index b16324d641..5705d9a7bb 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -1,19 +1,6 @@
 from __future__ import annotations
 from .circus import CircusMerging
+from .lussac import LussacMerging
 from .drift import DriftMerging
 
-
-merging_methods = {"circus": CircusMerging, "drift": DriftMerging}
-
-
-try:
-    import lussac.utils as utils
-
-    HAVE_LUSSAC = True
-except Exception:
-    HAVE_LUSSAC = False
-
-if HAVE_LUSSAC:
-    from .lussac import LussacMerging
-
-    merging_methods = {"lussac": LussacMerging}
+merging_methods = {"circus": CircusMerging, "drift": DriftMerging, "lussac": LussacMerging}

From 20e6ba97b7d5480c4ee45fe6c6ca3c9da8fe2087 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 12:10:36 +0200
Subject: [PATCH 028/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index a333af7812..df03d87025 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -150,7 +150,7 @@ def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
     return n_coincident + p_high * n_coincident_high + p_low * n_coincident_low
 
 
-def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[float, float]) -> float:
+def estimate_contamination(spike_train: np.ndarray, sf: float, T: int, refractory_period: tuple[float, float]) -> float:
     """
     Estimates the contamination of a spike train by looking at the number of refractory period violations.
     The spike train is assumed to have spikes coming from a neuron, and noisy spikes that are random and
@@ -179,6 +179,8 @@ def estimate_contamination(spike_train: np.ndarray, refractory_period: tuple[flo
 def estimate_cross_contamination(
     spike_train1: np.ndarray,
     spike_train2: np.ndarray,
+    sf: float,
+    T: int,
     refractory_period: tuple[float, float],
     limit: float | None = None,
 ) -> tuple[float, float] | float:
@@ -203,7 +205,7 @@ def estimate_cross_contamination(
 
     N1 = len(spike_train1)
     N2 = len(spike_train2)
-    C1 = estimate_contamination(spike_train1, refractory_period)
+    C1 = estimate_contamination(spike_train1, sf, T, refractory_period)
 
     t_c = refractory_period[0] * 1e-3 * sf
     t_r = refractory_period[1] * 1e-3 * sf
@@ -261,6 +263,8 @@ def aurelien_merge(
     pairs = []
     sorting = analyzer.sorting
     recording = analyzer.recording
+    sf = analyzer.recording.sampling_frequency
+    n_frames = analyzer.recording.get_num_samples()
 
     for unit_id1 in analyzer.unit_ids:
         for unit_id2 in analyzer.unit_ids:
@@ -304,7 +308,7 @@ def aurelien_merge(
             spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
             CC, p_value = estimate_cross_contamination(
-                spike_train1, spike_train2, refractory_period, limit=CC_threshold
+                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
 
             if p_value < 0.2:

From 60fc057e7c168847ebcaa74ecd9ebb8416a37858 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 13:28:53 +0200
Subject: [PATCH 029/164] WIP

---
 .../sorters/internal/spyking_circus2.py       | 30 +++----------------
 src/spikeinterface/sortingcomponents/tools.py |  3 +-
 2 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 5c105075e1..71844f28ab 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -210,6 +210,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
             clustering_params["ms_before"] = exclude_sweep_ms
             clustering_params["ms_after"] = exclude_sweep_ms
             clustering_params["tmp_folder"] = sorter_output_folder / "clustering"
+            clustering_params["verbose"] = verbose
 
             legacy = clustering_params.get("legacy", True)
 
@@ -323,7 +324,8 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 sorting.save(folder=curation_folder)
                 # np.save(fitting_folder / "amplitudes", guessed_amplitudes)
 
-            sorting = final_cleaning_circus(recording_w, sorting, templates, **merging_params)
+            merging_params['templates'] = templates
+            sorting = merge_spikes(recording_w, sorting, **merging_params)
 
             if verbose:
                 print(f"Final merging, keeping {len(sorting.unit_ids)} units")
@@ -341,28 +343,4 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
 
         sorting = sorting.save(folder=sorting_folder)
 
-        return sorting
-
-
-def final_cleaning_circus(recording, sorting, templates, **merging_kwargs):
-
-    from spikeinterface.sortingcomponents.clustering.clustering_tools import (
-        resolve_merging_graph,
-        apply_merges_to_sorting,
-    )
-
-    sparsity = templates.sparsity
-    templates_array = templates.get_dense_templates().copy()
-
-    sa = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
-
-    sa.extensions["templates"] = ComputeTemplates(sa)
-    sa.extensions["templates"].params = {"nbefore": templates.nbefore}
-    sa.extensions["templates"].data["average"] = templates_array
-    sa.compute("unit_locations", method="monopolar_triangulation")
-    merges = get_potential_auto_merge(sa, **merging_kwargs)
-    merges = resolve_merging_graph(sorting, merges)
-    sorting = apply_merges_to_sorting(sorting, merges)
-    # sorting = merge_units_sorting(sorting, merges)
-
-    return sorting
+        return sorting
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/tools.py b/src/spikeinterface/sortingcomponents/tools.py
index cf0d22c0c8..cd0ab32a14 100644
--- a/src/spikeinterface/sortingcomponents/tools.py
+++ b/src/spikeinterface/sortingcomponents/tools.py
@@ -80,7 +80,8 @@ def get_prototype_spike(recording, peaks, ms_before=0.5, ms_after=0.5, nb_peaks=
     waveforms = extract_waveform_at_max_channel(
         recording, some_peaks, ms_before=ms_before, ms_after=ms_after, **job_kwargs
     )
-    prototype = np.nanmedian(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
+    with np.errstate(divide='ignore'):
+        prototype = np.nanmedian(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
     return prototype
 
 

From 630273c03941b60e36e06c9c0b3a7bfeede98bca Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 May 2024 11:29:15 +0000
Subject: [PATCH 030/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 4 ++--
 src/spikeinterface/sortingcomponents/tools.py          | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 71844f28ab..171cb3cf8d 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -324,7 +324,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 sorting.save(folder=curation_folder)
                 # np.save(fitting_folder / "amplitudes", guessed_amplitudes)
 
-            merging_params['templates'] = templates
+            merging_params["templates"] = templates
             sorting = merge_spikes(recording_w, sorting, **merging_params)
 
             if verbose:
@@ -343,4 +343,4 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
 
         sorting = sorting.save(folder=sorting_folder)
 
-        return sorting
\ No newline at end of file
+        return sorting
diff --git a/src/spikeinterface/sortingcomponents/tools.py b/src/spikeinterface/sortingcomponents/tools.py
index cd0ab32a14..d8187205f7 100644
--- a/src/spikeinterface/sortingcomponents/tools.py
+++ b/src/spikeinterface/sortingcomponents/tools.py
@@ -80,7 +80,7 @@ def get_prototype_spike(recording, peaks, ms_before=0.5, ms_after=0.5, nb_peaks=
     waveforms = extract_waveform_at_max_channel(
         recording, some_peaks, ms_before=ms_before, ms_after=ms_after, **job_kwargs
     )
-    with np.errstate(divide='ignore'):
+    with np.errstate(divide="ignore"):
         prototype = np.nanmedian(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
     return prototype
 

From 3252e268491f97ff42614c96b2adb0990f055c44 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 31 May 2024 13:42:12 +0200
Subject: [PATCH 031/164] Fixing display

---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 71844f28ab..da53daf941 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -99,11 +99,12 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         from spikeinterface.sortingcomponents.merging import merge_spikes
         from spikeinterface.sortingcomponents.tools import remove_empty_templates
         from spikeinterface.sortingcomponents.tools import get_prototype_spike, check_probe_for_drift_correction
-        from spikeinterface.sortingcomponents.tools import get_prototype_spike
+        from spikeinterface.core.globals import set_global_job_kwargs, get_global_job_kwargs
 
-        job_kwargs = params["job_kwargs"]
+        job_kwargs_before = get_global_job_kwargs().copy()
+        job_kwargs = params["job_kwargs"].copy()
         job_kwargs = fix_job_kwargs(job_kwargs)
-        job_kwargs.update({"progress_bar": verbose})
+        set_global_job_kwargs(**job_kwargs)
 
         recording = cls.load_recording_from_folder(sorter_output_folder.parent, with_warnings=False)
 
@@ -342,5 +343,6 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
             shutil.rmtree(folder_to_delete)
 
         sorting = sorting.save(folder=sorting_folder)
+        set_global_job_kwargs(**job_kwargs_before)
 
         return sorting
\ No newline at end of file

From fea71b429a8b9d6fc3e783cbd9a776b844270eb5 Mon Sep 17 00:00:00 2001
From: Alessio Buccino <alejoe9187@gmail.com>
Date: Tue, 4 Jun 2024 12:08:01 +0200
Subject: [PATCH 032/164] Fix tests

---
 .../sortingcomponents/benchmark/tests/test_benchmark_merging.py  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index 4cbdb1beab..444ad0815d 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -1,5 +1,4 @@
 import pytest
-import pandas as pd
 from pathlib import Path
 import matplotlib.pyplot as plt
 import numpy as np

From 4bd5fb0b01cf041dba85f679227471d4c5b994fb Mon Sep 17 00:00:00 2001
From: Alessio Buccino <alejoe9187@gmail.com>
Date: Tue, 4 Jun 2024 12:53:21 +0200
Subject: [PATCH 033/164] Fix test imports

---
 .../benchmark/tests/test_benchmark_merging.py                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index 444ad0815d..999a80aadf 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -1,6 +1,5 @@
 import pytest
 from pathlib import Path
-import matplotlib.pyplot as plt
 import numpy as np
 
 import shutil
@@ -62,7 +61,8 @@ def test_benchmark_clustering():
     # study.plot_run_times()
     # study.plot_metrics_vs_snr("cosine")
     # study.homogeneity_score(ignore_noise=False)
-    plt.show()
+    # import matplotlib.pyplot as plt
+    # plt.show()
 
 
 if __name__ == "__main__":

From 982c065ce6718f8ac654c2fac4598c14051f2de2 Mon Sep 17 00:00:00 2001
From: Alessio Buccino <alejoe9187@gmail.com>
Date: Tue, 4 Jun 2024 13:06:34 +0200
Subject: [PATCH 034/164] Fix more test imports

---
 .../benchmark/benchmark_merging.py            |  10 +-
 .../sortingcomponents/merging/lussac.py       | 212 +++++++++---------
 2 files changed, 110 insertions(+), 112 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 1d81281f01..da38e5ad15 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 from spikeinterface.sortingcomponents.merging import merge_spikes
-from spikeinterface.core import NumpySorting
-from spikeinterface.comparison import CollisionGTComparison, compare_sorter_to_ground_truth
+from spikeinterface.comparison import compare_sorter_to_ground_truth
 from spikeinterface.widgets import (
     plot_agreement_matrix,
     plot_unit_templates,
@@ -10,11 +9,8 @@
     plot_crosscorrelograms,
 )
 
-import pylab as plt
-import matplotlib.patches as mpatches
 import numpy as np
 from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy
-from spikeinterface.core.basesorting import minimum_spike_dtype
 
 
 class MergingBenchmark(Benchmark):
@@ -95,6 +91,8 @@ def get_count_units(self, case_keys=None, well_detected_score=None, redundant_sc
         return count_units
 
     def plot_agreements(self, case_keys=None, figsize=(15, 15)):
+        import matplotlib.pyplot as plt
+
         if case_keys is None:
             case_keys = list(self.cases.keys())
 
@@ -171,7 +169,7 @@ def visualize_splits(self, case_key, figsize=(15, 5)):
         src, tgt = splits[:, 0], splits[:, 1]
         src = analyzer.sorting.ids_to_indices(src)
         tgt = analyzer.sorting.ids_to_indices(tgt)
-        import pylab as plt
+        import matplotlib.pyplot as plt
 
         fig, axs = plt.subplots(ncols=2, nrows=2, figsize=figsize, squeeze=True)
         axs[0, 0].scatter(distances["similarity"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index df03d87025..a0aa2794b2 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -42,112 +42,112 @@ def binom_sf(x: int, n: float, p: float) -> float:
     return f(n)
 
 
-@numba.jit((numba.float32,), nopython=True, nogil=True, cache=True)
-def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
-    """
-    Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
-
-    @param max_time: float
-        The maximum time between 2 spikes to be considered as a coincidence.
-    @return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
-        The borders and their probabilities.
-    """
-
-    border_high = math.ceil(max_time)
-    border_low = math.floor(max_time)
-    p_high = 0.5 * (max_time - border_high + 1) ** 2
-    p_low = 0.5 * (1 - (max_time - border_low) ** 2) + (max_time - border_low)
-
-    if border_low == 0:
-        p_low -= 0.5 * (-max_time + 1) ** 2
-
-    return border_low, border_high, p_low, p_high
-
-
-@numba.jit((numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
-def compute_nb_violations(spike_train, max_time) -> float:
-    """
-    Computes the number of refractory period violations in a spike train.
-
-    @param spike_train: array[int64] (n_spikes)
-        The spike train to compute the number of violations for.
-    @param max_time: float32
-        The maximum time to consider for violations (in number of samples).
-    @return n_violations: float
-        The number of spike pairs that violate the refractory period.
-    """
-
-    if max_time <= 0.0:
-        return 0.0
-
-    border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
-    n_violations = 0
-    n_violations_low = 0
-    n_violations_high = 0
-
-    for i in range(len(spike_train) - 1):
-        for j in range(i + 1, len(spike_train)):
-            diff = spike_train[j] - spike_train[i]
-
-            if diff > border_high:
-                break
-            if diff == border_high:
-                n_violations_high += 1
-            elif diff == border_low:
-                n_violations_low += 1
-            else:
-                n_violations += 1
-
-    return n_violations + p_high * n_violations_high + p_low * n_violations_low
-
-
-@numba.jit((numba.int64[:], numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
-def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
-    """
-    Computes the number of coincident spikes between two spike trains.
-    Spike timings are integers, so their real timing follows a uniform distribution between t - dt/2 and t + dt/2.
-    Under the assumption that the uniform distributions from two spikes are independent, we can compute the probability
-    of those two spikes being closer than the coincidence window:
-    f(x) = 1/2 (x+1)² if -1 <= x <= 0
-    f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
-    where x is the distance between max_time floor/ceil(max_time)
-
-    @param spike_train1: array[int64] (n_spikes1)
-        The spike train of the first unit.
-    @param spike_train2: array[int64] (n_spikes2)
-        The spike train of the second unit.
-    @param max_time: float32
-        The maximum time to consider for coincidence (in number samples).
-    @return n_coincidence: float
-        The number of coincident spikes.
-    """
-
-    if max_time <= 0:
-        return 0.0
-
-    border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
-    n_coincident = 0
-    n_coincident_low = 0
-    n_coincident_high = 0
-
-    start_j = 0
-    for i in range(len(spike_train1)):
-        for j in range(start_j, len(spike_train2)):
-            diff = spike_train1[i] - spike_train2[j]
-
-            if diff > border_high:
-                start_j += 1
-                continue
-            if diff < -border_high:
-                break
-            if abs(diff) == border_high:
-                n_coincident_high += 1
-            elif abs(diff) == border_low:
-                n_coincident_low += 1
-            else:
-                n_coincident += 1
-
-    return n_coincident + p_high * n_coincident_high + p_low * n_coincident_low
+if HAVE_NUMBA:
+
+    @numba.jit((numba.float32,), nopython=True, nogil=True, cache=True)
+    def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
+        """
+        Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
+
+        @param max_time: float
+            The maximum time between 2 spikes to be considered as a coincidence.
+        @return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
+            The borders and their probabilities.
+        """
+
+        border_high = math.ceil(max_time)
+        border_low = math.floor(max_time)
+        p_high = 0.5 * (max_time - border_high + 1) ** 2
+        p_low = 0.5 * (1 - (max_time - border_low) ** 2) + (max_time - border_low)
+
+        if border_low == 0:
+            p_low -= 0.5 * (-max_time + 1) ** 2
+
+        return border_low, border_high, p_low, p_high
+
+    @numba.jit((numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
+    def compute_nb_violations(spike_train, max_time) -> float:
+        """
+        Computes the number of refractory period violations in a spike train.
+
+        @param spike_train: array[int64] (n_spikes)
+            The spike train to compute the number of violations for.
+        @param max_time: float32
+            The maximum time to consider for violations (in number of samples).
+        @return n_violations: float
+            The number of spike pairs that violate the refractory period.
+        """
+
+        if max_time <= 0.0:
+            return 0.0
+
+        border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
+        n_violations = 0
+        n_violations_low = 0
+        n_violations_high = 0
+
+        for i in range(len(spike_train) - 1):
+            for j in range(i + 1, len(spike_train)):
+                diff = spike_train[j] - spike_train[i]
+
+                if diff > border_high:
+                    break
+                if diff == border_high:
+                    n_violations_high += 1
+                elif diff == border_low:
+                    n_violations_low += 1
+                else:
+                    n_violations += 1
+
+        return n_violations + p_high * n_violations_high + p_low * n_violations_low
+
+    @numba.jit((numba.int64[:], numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
+    def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
+        """
+        Computes the number of coincident spikes between two spike trains.
+        Spike timings are integers, so their real timing follows a uniform distribution between t - dt/2 and t + dt/2.
+        Under the assumption that the uniform distributions from two spikes are independent, we can compute the probability
+        of those two spikes being closer than the coincidence window:
+        f(x) = 1/2 (x+1)² if -1 <= x <= 0
+        f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
+        where x is the distance between max_time floor/ceil(max_time)
+
+        @param spike_train1: array[int64] (n_spikes1)
+            The spike train of the first unit.
+        @param spike_train2: array[int64] (n_spikes2)
+            The spike train of the second unit.
+        @param max_time: float32
+            The maximum time to consider for coincidence (in number samples).
+        @return n_coincidence: float
+            The number of coincident spikes.
+        """
+
+        if max_time <= 0:
+            return 0.0
+
+        border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
+        n_coincident = 0
+        n_coincident_low = 0
+        n_coincident_high = 0
+
+        start_j = 0
+        for i in range(len(spike_train1)):
+            for j in range(start_j, len(spike_train2)):
+                diff = spike_train1[i] - spike_train2[j]
+
+                if diff > border_high:
+                    start_j += 1
+                    continue
+                if diff < -border_high:
+                    break
+                if abs(diff) == border_high:
+                    n_coincident_high += 1
+                elif abs(diff) == border_low:
+                    n_coincident_low += 1
+                else:
+                    n_coincident += 1
+
+        return n_coincident + p_high * n_coincident_high + p_low * n_coincident_low
 
 
 def estimate_contamination(spike_train: np.ndarray, sf: float, T: int, refractory_period: tuple[float, float]) -> float:

From c51e79d5b67d4302719eff353ef8c48b96bb9f15 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Tue, 4 Jun 2024 13:21:58 +0200
Subject: [PATCH 035/164] Renaming the drift suggestion for meta merging

---
 src/spikeinterface/curation/auto_merge.py     |   2 +-
 .../curation/merge_temporal_splits.py         | 226 ++++++++++++++++++
 src/spikeinterface/generation/drift_tools.py  |  10 +-
 .../sortingcomponents/merging/drift.py        |  99 --------
 4 files changed, 235 insertions(+), 102 deletions(-)
 create mode 100644 src/spikeinterface/curation/merge_temporal_splits.py

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 05cbbf5f34..0bb62276af 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -13,7 +13,7 @@
 
 def get_potential_auto_merge(
     sorting_analyzer,
-    minimum_spikes=1000,
+    minimum_spikes=100,
     maximum_distance_um=150.0,
     peak_sign="neg",
     bin_ms=0.25,
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
new file mode 100644
index 0000000000..2a28239c8f
--- /dev/null
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -0,0 +1,226 @@
+from __future__ import annotations
+import numpy as np
+
+from .auto_merge import check_improve_contaminations_score, compute_templates_diff,compute_refrac_period_violations
+
+
+def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
+    """
+    Compute the presence distance between two units.
+
+    The presence distance is defined as the sum of the absolute difference between the sum of
+    the normalized firing profiles of the two units and a constant firing profile.
+
+    Parameters
+    ----------
+    sorting: Sorting
+        The sorting object.
+    unit1: int or str
+        The id of the first unit.
+    unit2: int or str
+        The id of the second unit.
+    bin_duration_s: float
+        The duration of the bin in seconds.
+    percentile_norm: float
+        The percentile used to normalize the firing rate.
+    bins: array-like
+        The bins used to compute the firing rate.
+
+    Returns
+    -------
+    d: float
+        The presence distance between the two units.
+    """
+    if bins is None:
+        bin_size = bin_duration_s * sorting.sampling_frequency
+        bins = np.arange(0, sorting.get_num_samples(), bin_size)
+
+    st1 = sorting.get_unit_spike_train(unit_id=unit1)
+    st2 = sorting.get_unit_spike_train(unit_id=unit2)
+
+    h1, _ = np.histogram(st1, bins)
+    h1 = h1.astype(float)
+    norm_value1 = np.percentile(h1, percentile_norm)
+
+    h2, _ = np.histogram(st2, bins)
+    h2 = h2.astype(float)
+    norm_value2 = np.percentile(h2, percentile_norm)
+
+    if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
+        h1 = h1 / norm_value1
+        h2 = h2 / norm_value2
+        d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / sorting.get_total_duration()
+    else:
+        d = 1.0
+
+    return d
+
+def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
+    """
+    Get the potential drift-related merges based on similarity and presence completeness.
+
+    Parameters
+    ----------
+    sorting: Sorting
+        The sorting object
+    pair_mask: None or boolean array
+        A bool matrix of size (num_units, num_units) to select
+        which pair to compute.
+    presence_distance_threshold: float
+        The presence distance threshold used to consider two units as similar
+    presence_distance_kwargs: A dictionary of kwargs to be passed to compute_presence_distance()
+
+    Returns
+    -------
+    potential_merges: list
+        The list of potential merges
+
+    """
+
+    unit_ids = sorting.unit_ids
+    n = len(unit_ids)
+
+    if pair_mask is None:
+        pair_mask = np.ones((n, n), dtype="bool")
+
+    distances = np.ones((sorting.get_num_units(), sorting.get_num_units()))
+
+    for unit_ind1 in range(n):
+        for unit_ind2 in range(unit_ind1 + 1, n):
+            if not pair_mask[unit_ind1, unit_ind2]:
+                continue
+            unit1 = unit_ids[unit_ind1]
+            unit2 = unit_ids[unit_ind2]
+            d = presence_distance(sorting, unit1, unit2, **presence_distance_kwargs)
+            distances[unit_ind1, unit_ind2] = d
+    presence_distances = np.triu(distances)
+    return presence_distances
+
+
+def get_potential_temporal_splits(sorting_analyzer, 
+                                  minimum_spikes=100,
+                                  presence_distance_threshold=0.1, 
+                                  template_diff_thresh=0.25,
+                                  censored_period_ms=0.3,
+                                  refractory_period_ms=1.0,
+                                  num_channels=5,
+                                  num_shift=5,
+                                  contamination_threshold=0.2,
+                                  firing_contamination_balance=1.5,
+                                  extra_outputs=False,
+                                  steps=None,
+                                  template_metric="l1",
+                                  **presence_distance_kwargs):
+    
+    """
+    Algorithm to find and check potential temporal merges between units.
+
+    The merges are proposed when the following criteria are met:
+
+        * STEP 1: enough spikes are found in each units for computing the correlogram (`minimum_spikes`)
+        * STEP 2: the templates of the two units are similar (`template_diff_thresh`)
+        * STEP 3: the presence distance of the two units is high
+        * STEP 4: the unit "quality score" is increased after the merge.
+
+    The "quality score" factors in the increase in firing rate (**f**) due to the merge and a possible increase in
+    contamination (**C**), wheighted by a factor **k** (`firing_contamination_balance`).
+
+    .. math::
+
+        Q = f(1 - (k + 1)C)
+
+    
+    """
+
+    import scipy
+
+    sorting = sorting_analyzer.sorting
+    recording = sorting_analyzer.recording
+    unit_ids = sorting.unit_ids
+    sorting.register_recording(recording)
+
+    # to get fast computation we will not analyse pairs when:
+    #    * not enough spikes for one of theses
+    #    * auto correlogram is contaminated
+    #    * to far away one from each other
+
+    if steps is None:
+        steps = [
+            "min_spikes",
+            "remove_contaminated",
+            "template_similarity",
+            "presence_distance",
+            "check_increase_score",
+        ]
+
+    n = unit_ids.size
+    pair_mask = np.ones((n, n), dtype="bool")
+
+    # STEP 1 :
+    if "min_spikes" in steps:
+        num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
+        to_remove = num_spikes < minimum_spikes
+        pair_mask[to_remove, :] = False
+        pair_mask[:, to_remove] = False
+    
+    # STEP 2 : remove contaminated auto corr
+    if "remove_contaminated" in steps:
+        contaminations, nb_violations = compute_refrac_period_violations(
+            sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
+        )
+        nb_violations = np.array(list(nb_violations.values()))
+        contaminations = np.array(list(contaminations.values()))
+        to_remove = contaminations > contamination_threshold
+        pair_mask[to_remove, :] = False
+        pair_mask[:, to_remove] = False
+    
+    # STEP 2 : check if potential merge with CC also have template similarity
+    if "template_similarity" in steps:
+        templates_ext = sorting_analyzer.get_extension("templates")
+        assert (
+            templates_ext is not None
+        ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
+
+        templates_array = templates_ext.get_data(outputs="numpy")
+        
+        templates_diff = compute_templates_diff(
+            sorting,
+            templates_array,
+            num_channels=num_channels,
+            num_shift=num_shift,
+            pair_mask=pair_mask,
+            template_metric=template_metric,
+            sparsity=sorting_analyzer.sparsity,
+        )
+
+        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+
+    # STEP 3 : validate the potential merges with CC increase the contamination quality metrics
+    if "presence_distance" in steps:        
+        presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
+        pair_mask = pair_mask & (presence_distances < presence_distance_threshold)
+
+    # STEP 4 : validate the potential merges with CC increase the contamination quality metrics
+    if "check_increase_score" in steps:
+        pair_mask, pairs_decreased_score = check_improve_contaminations_score(
+            sorting_analyzer,
+            pair_mask,
+            contaminations,
+            firing_contamination_balance,
+            refractory_period_ms,
+            censored_period_ms,
+       )
+    
+    # FINAL STEP : create the final list from pair_mask boolean matrix
+    ind1, ind2 = np.nonzero(pair_mask)
+    potential_merges = list(zip(unit_ids[ind1], unit_ids[ind2]))
+
+    if extra_outputs:
+        outs = dict(
+            templates_diff=templates_diff,
+            presence_distances=presence_distances,
+            pairs_decreased_score=pairs_decreased_score,
+        )
+        return potential_merges, outs
+    else:
+        return potential_merges
\ No newline at end of file
diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index e4e119b0d4..0e54b4dd7a 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -3,6 +3,7 @@
 
 import numpy as np
 from numpy.typing import ArrayLike
+from spikeinterface.core.sortinganalyzer import SortingAnalyzer
 from spikeinterface.core import Templates, BaseRecording, BaseSorting, BaseRecordingSegment
 import math
 
@@ -515,8 +516,13 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-def split_sorting_by_time(sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
-    sorting = sorting_analyzer.sorting
+def split_sorting_by_time(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
+    
+    if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
+        sorting = sorting_analyzer.sorting
+    else:
+        sorting = sorting_or_sorting_analyzer
+        
     sorting_split = sorting.select_units(sorting.unit_ids)
     split_units = []
     original_units = []
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
index 968a7c81d2..c1ad178499 100644
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -6,105 +6,6 @@
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
-
-def compute_presence_distance(analyzer, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
-    """
-    Compute the presence distance between two units.
-
-    The presence distance is defined as the sum of the absolute difference between the sum of
-    the normalized firing profiles of the two units and a constant firing profile.
-
-    Parameters
-    ----------
-    analyzer: SortingAnalyzer
-        The sorting analyzer object.
-    unit1: int or str
-        The id of the first unit.
-    unit2: int or str
-        The id of the second unit.
-    bin_duration_s: float
-        The duration of the bin in seconds.
-    percentile_norm: float
-        The percentile used to normalize the firing rate.
-    bins: array-like
-        The bins used to compute the firing rate.
-
-    Returns
-    -------
-    d: float
-        The presence distance between the two units.
-    """
-    if bins is None:
-        bin_size = bin_duration_s * analyzer.sampling_frequency
-        bins = np.arange(0, analyzer.get_num_samples(), bin_size)
-
-    st1 = analyzer.sorting.get_unit_spike_train(unit_id=unit1)
-    st2 = analyzer.sorting.get_unit_spike_train(unit_id=unit2)
-
-    h1, _ = np.histogram(st1, bins)
-    h1 = h1.astype(float)
-    norm_value1 = np.percentile(h1, percentile_norm)
-
-    h2, _ = np.histogram(st2, bins)
-    h2 = h2.astype(float)
-    norm_value2 = np.percentile(h2, percentile_norm)
-
-    if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
-        h1 = h1 / norm_value1
-        h2 = h2 / norm_value2
-        d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / analyzer.get_total_duration()
-    else:
-        d = np.nan
-
-    return d
-
-
-def get_potential_drift_merges(analyzer, similarity_threshold=0.7, presence_distance_threshold=0.1, bin_duration_s=2):
-    """
-    Get the potential drift-related merges based on similarity and presence completeness.
-
-    Parameters
-    ----------
-    analyzer: SortingAnalyzer
-        The sorting analyzer object
-    similarity_threshold: float
-        The similarity threshold used to consider two units as similar
-    presence_distance_threshold: float
-        The presence distance threshold used to consider two units as similar
-    bin_duration_s: float
-        The duration of the bin in seconds
-
-    Returns
-    -------
-    potential_merges: list
-        The list of potential merges
-
-    """
-    assert analyzer.get_extension("templates") is not None, "The templates extension is required"
-    assert analyzer.get_extension("template_similarity") is not None, "The template_similarity extension is required"
-    distances = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
-    similarity = analyzer.get_extension("template_similarity").get_data()
-
-    bin_size = bin_duration_s * analyzer.sampling_frequency
-    bins = np.arange(0, analyzer.get_num_samples(), bin_size)
-
-    for i, unit1 in enumerate(analyzer.unit_ids):
-        for j, unit2 in enumerate(analyzer.unit_ids):
-            if i != j and similarity[i, j] > similarity_threshold:
-                d = compute_presence_distance(analyzer, unit1, unit2, bins=bins)
-                distances[i, j] = d
-            else:
-                distances[i, j] = 1
-    distance_thr = np.triu(distances)
-    distance_thr[distance_thr == 0] = np.nan
-    distance_thr[similarity < similarity_threshold] = np.nan
-    distance_thr[distance_thr > presence_distance_threshold] = np.nan
-    potential_merges = analyzer.unit_ids[np.array(np.nonzero(np.logical_not(np.isnan(distance_thr)))).T]
-    potential_merges = [tuple(merge) for merge in potential_merges]
-
-    return potential_merges
-
-
 class DriftMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric

From 31d8180ec258ad596afa93b07615b600352b8696 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Tue, 4 Jun 2024 13:39:29 +0200
Subject: [PATCH 036/164] WIP

---
 .../benchmark/tests/test_benchmark_merging.py | 27 +++++++++++--------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index 4cbdb1beab..3360753e79 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -8,11 +8,11 @@
 
 from spikeinterface.sortingcomponents.benchmark.tests.common_benchmark_testing import make_dataset, cache_folder
 from spikeinterface.sortingcomponents.benchmark.benchmark_merging import MergingStudy
-from spikeinterface.generation.drift_tools import split_sorting_by_amplitudes
+from spikeinterface.generation.drift_tools import split_sorting_by_amplitudes, split_sorting_by_times
 
 
 @pytest.mark.skip()
-def test_benchmark_clustering():
+def test_benchmark_merging():
 
     job_kwargs = dict(n_jobs=0.8, chunk_duration="1s")
 
@@ -24,16 +24,21 @@ def test_benchmark_clustering():
     datasets = {"toy": gt_analyzer}
 
     gt_analyzer.compute(["random_spikes", "templates", "spike_amplitudes"])
-    new_sorting_amp, splitted_cells_amp = split_sorting_by_amplitudes(gt_analyzer)
+
+    splitted_sorting = {}
+    splitted_sorting['times'] = split_sorting_by_times(gt_analyzer)
+    splitted_sorting['amplitudes'] = split_sorting_by_amplitudes(gt_analyzer)
 
     cases = {}
-    for method in ["circus", "lussac"]:
-        cases[method] = {
-            "label": f"{method} on toy",
-            "dataset": "toy",
-            "init_kwargs": {"gt_sorting": gt_sorting, "splitted_cells": splitted_cells_amp},
-            "params": {"method": method, "splitted_sorting": new_sorting_amp, "method_kwargs": {}},
-        }
+    for splits in ['times', 'amplitudes']:
+        for method in ["circus", "lussac"]:
+            cases[(method, splits)] = {
+                "label": f"{method}",
+                "dataset": "toy",
+                "init_kwargs": {"gt_sorting": gt_sorting, "splitted_cells": splitted_sorting[splits][1]},
+                "params": {"method": method, "splitted_sorting": splitted_sorting[splits][0], "method_kwargs": {}},
+            }
+
 
     if study_folder.exists():
         shutil.rmtree(study_folder)
@@ -57,7 +62,7 @@ def test_benchmark_clustering():
     # plots
     # study.plot_performances_vs_snr()
     study.plot_agreements()
-    # study.plot_comparison_clustering()
+    study.plot_unit_counts()
     # study.plot_error_metrics()
     # study.plot_metrics_vs_snr()
     # study.plot_run_times()

From 719a688e96e1ae1699c4638428190843594a5b75 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Tue, 4 Jun 2024 13:39:53 +0200
Subject: [PATCH 037/164] WIP

---
 src/spikeinterface/generation/drift_tools.py  |  4 ++--
 .../sortingcomponents/merging/circus.py       | 21 +++++++++++++------
 .../sortingcomponents/merging/drift.py        | 19 +++++++++++++----
 3 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index 0e54b4dd7a..45068f4031 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -516,10 +516,10 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-def split_sorting_by_time(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
+def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
     
     if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
-        sorting = sorting_analyzer.sorting
+        sorting = sorting_or_sorting_analyzer.sorting
     else:
         sorting = sorting_or_sorting_analyzer
         
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index e2d0417654..89313040fc 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -5,6 +5,7 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
+from spikeinterface.curation.merge_temporal_splits import get_potential_temporal_splits
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 
@@ -15,11 +16,17 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "minimum_spikes": 50,
-        "corr_diff_thresh": 0.5,
-        "template_metric": "cosine",
-        "num_channels": None,
-        "num_shift": 5,
+        "curation_kwargs" : {
+            "minimum_spikes": 50,
+            "corr_diff_thresh": 0.5,
+            "template_metric": "cosine",
+            "num_channels": None,
+            "num_shift": 5,
+        },
+        "temporal_splits_kwargs" :  {
+            "minimum_spikes": 50,
+            "presence_distance_threshold": 0.1,
+        }
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -39,9 +46,11 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+        self.analyzer.compute(["template_similarity"])
 
     def run(self, extra_outputs=False):
-        merges = get_potential_auto_merge(self.analyzer, **self.default_params)
+        merges = get_potential_auto_merge(self.analyzer, **self.default_params['curation_kwargs'])
+        merges += get_potential_temporal_splits(self.analyzer, **self.default_params['temporal_splits_kwargs'])
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
index c1ad178499..1fbb1acf58 100644
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -5,6 +5,8 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
+from spikeinterface.curation.merge_temporal_splits import get_potential_temporal_splits
+from spikeinterface.curation.auto_merge import get_potential_auto_merge
 
 class DriftMerging(BaseMergingEngine):
     """
@@ -13,9 +15,17 @@ class DriftMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "similarity_threshold": 0.7,
-        "presence_distance_threshold": 0.1,
-        "bin_duration_s": 2,
+        "curation_kwargs" : {
+            "minimum_spikes": 50,
+            "corr_diff_thresh": 0.5,
+            "template_metric": "cosine",
+            "num_channels": None,
+            "num_shift": 5,
+        },
+        "temporal_splits_kwargs" :  {
+            "minimum_spikes": 50,
+            "presence_distance_threshold": 0.1,
+        }
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -38,7 +48,8 @@ def __init__(self, recording, sorting, kwargs):
         self.analyzer.compute(["template_similarity"])
 
     def run(self, extra_outputs=False):
-        merges = get_potential_drift_merges(self.analyzer, **self.default_params)
+        merges = get_potential_auto_merge(self.analyzer, **self.default_params['curation_kwargs'])
+        merges += get_potential_temporal_splits(self.analyzer, **self.default_params['temporal_splits_kwargs'])
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:

From da862d1a9d7a77ca0b360fc625667b78b962d0fb Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 4 Jun 2024 11:42:50 +0000
Subject: [PATCH 038/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../curation/merge_temporal_splits.py         | 50 ++++++++++---------
 src/spikeinterface/generation/drift_tools.py  |  4 +-
 .../benchmark/tests/test_benchmark_merging.py |  7 ++-
 .../sortingcomponents/merging/circus.py       | 10 ++--
 .../sortingcomponents/merging/drift.py        | 11 ++--
 5 files changed, 42 insertions(+), 40 deletions(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 2a28239c8f..ac455d6187 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 import numpy as np
 
-from .auto_merge import check_improve_contaminations_score, compute_templates_diff,compute_refrac_period_violations
+from .auto_merge import check_improve_contaminations_score, compute_templates_diff, compute_refrac_period_violations
 
 
 def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
@@ -55,6 +55,7 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=9
 
     return d
 
+
 def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
     """
     Get the potential drift-related merges based on similarity and presence completeness.
@@ -97,21 +98,22 @@ def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
     return presence_distances
 
 
-def get_potential_temporal_splits(sorting_analyzer, 
-                                  minimum_spikes=100,
-                                  presence_distance_threshold=0.1, 
-                                  template_diff_thresh=0.25,
-                                  censored_period_ms=0.3,
-                                  refractory_period_ms=1.0,
-                                  num_channels=5,
-                                  num_shift=5,
-                                  contamination_threshold=0.2,
-                                  firing_contamination_balance=1.5,
-                                  extra_outputs=False,
-                                  steps=None,
-                                  template_metric="l1",
-                                  **presence_distance_kwargs):
-    
+def get_potential_temporal_splits(
+    sorting_analyzer,
+    minimum_spikes=100,
+    presence_distance_threshold=0.1,
+    template_diff_thresh=0.25,
+    censored_period_ms=0.3,
+    refractory_period_ms=1.0,
+    num_channels=5,
+    num_shift=5,
+    contamination_threshold=0.2,
+    firing_contamination_balance=1.5,
+    extra_outputs=False,
+    steps=None,
+    template_metric="l1",
+    **presence_distance_kwargs,
+):
     """
     Algorithm to find and check potential temporal merges between units.
 
@@ -129,7 +131,7 @@ def get_potential_temporal_splits(sorting_analyzer,
 
         Q = f(1 - (k + 1)C)
 
-    
+
     """
 
     import scipy
@@ -162,7 +164,7 @@ def get_potential_temporal_splits(sorting_analyzer,
         to_remove = num_spikes < minimum_spikes
         pair_mask[to_remove, :] = False
         pair_mask[:, to_remove] = False
-    
+
     # STEP 2 : remove contaminated auto corr
     if "remove_contaminated" in steps:
         contaminations, nb_violations = compute_refrac_period_violations(
@@ -173,7 +175,7 @@ def get_potential_temporal_splits(sorting_analyzer,
         to_remove = contaminations > contamination_threshold
         pair_mask[to_remove, :] = False
         pair_mask[:, to_remove] = False
-    
+
     # STEP 2 : check if potential merge with CC also have template similarity
     if "template_similarity" in steps:
         templates_ext = sorting_analyzer.get_extension("templates")
@@ -182,7 +184,7 @@ def get_potential_temporal_splits(sorting_analyzer,
         ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
 
         templates_array = templates_ext.get_data(outputs="numpy")
-        
+
         templates_diff = compute_templates_diff(
             sorting,
             templates_array,
@@ -196,7 +198,7 @@ def get_potential_temporal_splits(sorting_analyzer,
         pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
     # STEP 3 : validate the potential merges with CC increase the contamination quality metrics
-    if "presence_distance" in steps:        
+    if "presence_distance" in steps:
         presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
         pair_mask = pair_mask & (presence_distances < presence_distance_threshold)
 
@@ -209,8 +211,8 @@ def get_potential_temporal_splits(sorting_analyzer,
             firing_contamination_balance,
             refractory_period_ms,
             censored_period_ms,
-       )
-    
+        )
+
     # FINAL STEP : create the final list from pair_mask boolean matrix
     ind1, ind2 = np.nonzero(pair_mask)
     potential_merges = list(zip(unit_ids[ind1], unit_ids[ind2]))
@@ -223,4 +225,4 @@ def get_potential_temporal_splits(sorting_analyzer,
         )
         return potential_merges, outs
     else:
-        return potential_merges
\ No newline at end of file
+        return potential_merges
diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index 45068f4031..93b391d5cc 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -517,12 +517,12 @@ def get_num_samples(self) -> int:
 
 
 def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
-    
+
     if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
         sorting = sorting_or_sorting_analyzer.sorting
     else:
         sorting = sorting_or_sorting_analyzer
-        
+
     sorting_split = sorting.select_units(sorting.unit_ids)
     split_units = []
     original_units = []
diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index b9beb4ff31..7844f38ed7 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -24,11 +24,11 @@ def test_benchmark_merging():
     gt_analyzer.compute(["random_spikes", "templates", "spike_amplitudes"])
 
     splitted_sorting = {}
-    splitted_sorting['times'] = split_sorting_by_times(gt_analyzer)
-    splitted_sorting['amplitudes'] = split_sorting_by_amplitudes(gt_analyzer)
+    splitted_sorting["times"] = split_sorting_by_times(gt_analyzer)
+    splitted_sorting["amplitudes"] = split_sorting_by_amplitudes(gt_analyzer)
 
     cases = {}
-    for splits in ['times', 'amplitudes']:
+    for splits in ["times", "amplitudes"]:
         for method in ["circus", "lussac"]:
             cases[(method, splits)] = {
                 "label": f"{method}",
@@ -37,7 +37,6 @@ def test_benchmark_merging():
                 "params": {"method": method, "splitted_sorting": splitted_sorting[splits][0], "method_kwargs": {}},
             }
 
-
     if study_folder.exists():
         shutil.rmtree(study_folder)
     study = MergingStudy.create(study_folder, datasets=datasets, cases=cases)
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 89313040fc..e125a93350 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,17 +16,17 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "curation_kwargs" : {
+        "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
             "num_channels": None,
             "num_shift": 5,
         },
-        "temporal_splits_kwargs" :  {
+        "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
-        }
+        },
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -49,8 +49,8 @@ def __init__(self, recording, sorting, kwargs):
         self.analyzer.compute(["template_similarity"])
 
     def run(self, extra_outputs=False):
-        merges = get_potential_auto_merge(self.analyzer, **self.default_params['curation_kwargs'])
-        merges += get_potential_temporal_splits(self.analyzer, **self.default_params['temporal_splits_kwargs'])
+        merges = get_potential_auto_merge(self.analyzer, **self.default_params["curation_kwargs"])
+        merges += get_potential_temporal_splits(self.analyzer, **self.default_params["temporal_splits_kwargs"])
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
index 1fbb1acf58..dc83acaaeb 100644
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ b/src/spikeinterface/sortingcomponents/merging/drift.py
@@ -8,6 +8,7 @@
 from spikeinterface.curation.merge_temporal_splits import get_potential_temporal_splits
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
 
+
 class DriftMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric
@@ -15,17 +16,17 @@ class DriftMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "curation_kwargs" : {
+        "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
             "num_channels": None,
             "num_shift": 5,
         },
-        "temporal_splits_kwargs" :  {
+        "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
-        }
+        },
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -48,8 +49,8 @@ def __init__(self, recording, sorting, kwargs):
         self.analyzer.compute(["template_similarity"])
 
     def run(self, extra_outputs=False):
-        merges = get_potential_auto_merge(self.analyzer, **self.default_params['curation_kwargs'])
-        merges += get_potential_temporal_splits(self.analyzer, **self.default_params['temporal_splits_kwargs'])
+        merges = get_potential_auto_merge(self.analyzer, **self.default_params["curation_kwargs"])
+        merges += get_potential_temporal_splits(self.analyzer, **self.default_params["temporal_splits_kwargs"])
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:

From 9a69b14237d0c4462359c7da5556e0c0a986c013 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 4 Jun 2024 14:18:23 +0200
Subject: [PATCH 039/164] Harmonize

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index e125a93350..9b81ac949e 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -21,11 +21,14 @@ class CircusMerging(BaseMergingEngine):
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
             "num_channels": None,
-            "num_shift": 5,
+            "num_shift": 10,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
+            "template_metric": "cosine",
+            "num_channels": None,
+            "num_shift": 10,
         },
     }
 

From 2eee74ec8025ec846b10f76a42e955c2560cfd00 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 4 Jun 2024 14:21:48 +0200
Subject: [PATCH 040/164] CircusMerging is now able to do handle drift

---
 .../sortingcomponents/merging/circus.py       | 12 +++-
 .../sortingcomponents/merging/drift.py        | 59 -------------------
 .../sortingcomponents/merging/method_list.py  |  3 +-
 3 files changed, 11 insertions(+), 63 deletions(-)
 delete mode 100644 src/spikeinterface/sortingcomponents/merging/drift.py

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 9b81ac949e..a6dd29dab9 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -52,8 +52,16 @@ def __init__(self, recording, sorting, kwargs):
         self.analyzer.compute(["template_similarity"])
 
     def run(self, extra_outputs=False):
-        merges = get_potential_auto_merge(self.analyzer, **self.default_params["curation_kwargs"])
-        merges += get_potential_temporal_splits(self.analyzer, **self.default_params["temporal_splits_kwargs"])
+        curation_kwargs = self.default_params.get('curation_kwargs', None)
+        if curation_kwargs is not None:
+            merges = get_potential_auto_merge(self.analyzer, **curation_kwargs)
+        else:
+            merges = []
+
+        temporal_splits_kwargs = self.default_params.get('temporal_splits_kwargs', None)
+        if temporal_splits_kwargs is not None:
+            merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
+
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:
diff --git a/src/spikeinterface/sortingcomponents/merging/drift.py b/src/spikeinterface/sortingcomponents/merging/drift.py
deleted file mode 100644
index dc83acaaeb..0000000000
--- a/src/spikeinterface/sortingcomponents/merging/drift.py
+++ /dev/null
@@ -1,59 +0,0 @@
-from __future__ import annotations
-import numpy as np
-
-from .main import BaseMergingEngine
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
-from spikeinterface.curation.merge_temporal_splits import get_potential_temporal_splits
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
-
-
-class DriftMerging(BaseMergingEngine):
-    """
-    Meta merging inspired from the Lussac metric
-    """
-
-    default_params = {
-        "templates": None,
-        "curation_kwargs": {
-            "minimum_spikes": 50,
-            "corr_diff_thresh": 0.5,
-            "template_metric": "cosine",
-            "num_channels": None,
-            "num_shift": 5,
-        },
-        "temporal_splits_kwargs": {
-            "minimum_spikes": 50,
-            "presence_distance_threshold": 0.1,
-        },
-    }
-
-    def __init__(self, recording, sorting, kwargs):
-        self.default_params.update(**kwargs)
-        self.sorting = sorting
-        self.recording = recording
-        self.templates = self.default_params.pop("templates", None)
-        if self.templates is not None:
-            sparsity = self.templates.sparsity
-            templates_array = self.templates.get_dense_templates().copy()
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
-            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
-            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
-            self.analyzer.extensions["templates"].data["average"] = templates_array
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        else:
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(["random_spikes", "templates"])
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        self.analyzer.compute(["template_similarity"])
-
-    def run(self, extra_outputs=False):
-        merges = get_potential_auto_merge(self.analyzer, **self.default_params["curation_kwargs"])
-        merges += get_potential_temporal_splits(self.analyzer, **self.default_params["temporal_splits_kwargs"])
-        merges = resolve_merging_graph(self.sorting, merges)
-        sorting = apply_merges_to_sorting(self.sorting, merges)
-        if extra_outputs:
-            return sorting, merges
-        else:
-            return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index 5705d9a7bb..db1bb116e3 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 from .circus import CircusMerging
 from .lussac import LussacMerging
-from .drift import DriftMerging
 
-merging_methods = {"circus": CircusMerging, "drift": DriftMerging, "lussac": LussacMerging}
+merging_methods = {"circus": CircusMerging, "lussac": LussacMerging}

From e153c156a22876bb80f3b722a86694efa0f0e423 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 4 Jun 2024 12:24:05 +0000
Subject: [PATCH 041/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index a6dd29dab9..ae8f04a1b6 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -52,13 +52,13 @@ def __init__(self, recording, sorting, kwargs):
         self.analyzer.compute(["template_similarity"])
 
     def run(self, extra_outputs=False):
-        curation_kwargs = self.default_params.get('curation_kwargs', None)
+        curation_kwargs = self.default_params.get("curation_kwargs", None)
         if curation_kwargs is not None:
             merges = get_potential_auto_merge(self.analyzer, **curation_kwargs)
         else:
             merges = []
 
-        temporal_splits_kwargs = self.default_params.get('temporal_splits_kwargs', None)
+        temporal_splits_kwargs = self.default_params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
             merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
 

From cd08b35fcf79a07cd7ba001baaf8e9fb97ce0037 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 4 Jun 2024 18:29:37 +0200
Subject: [PATCH 042/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index a6dd29dab9..1aa0c0ea0e 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -49,7 +49,8 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        self.analyzer.compute(["template_similarity"])
+        
+        #self.analyzer.compute(["template_similarity"], max_lag_ms=0.5, metric='cosine')
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.default_params.get('curation_kwargs', None)

From 4408a66df64ad2ab101015c63adfbf163b10f04b Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 5 Jun 2024 06:48:10 +0000
Subject: [PATCH 043/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 9994955062..3fedcd6580 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -49,8 +49,8 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        
-        #self.analyzer.compute(["template_similarity"], max_lag_ms=0.5, metric='cosine')
+
+        # self.analyzer.compute(["template_similarity"], max_lag_ms=0.5, metric='cosine')
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.default_params.get("curation_kwargs", None)

From d6a9c8d380b019ce12fe6d75cd2e04c3e37bf7f6 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 09:26:54 +0200
Subject: [PATCH 044/164] WIP

---
 src/spikeinterface/curation/auto_merge.py     |  47 ++++----
 .../benchmark/benchmark_merging.py            | 112 +++++++++---------
 .../sortingcomponents/merging/circus.py       |   4 +-
 3 files changed, 83 insertions(+), 80 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 0bb62276af..d6917a6f41 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -442,6 +442,7 @@ def compute_templates_diff(
         sparsity_mask = sparsity.mask
 
     templates_diff = np.full((n, n), np.nan, dtype="float64")
+    all_shifts = range(-num_shift, num_shift + 1)
     for unit_ind1 in range(n):
         for unit_ind2 in range(unit_ind1 + 1, n):
             if not pair_mask[unit_ind1, unit_ind2]:
@@ -453,31 +454,33 @@ def compute_templates_diff(
             if not adaptative_masks:
                 chan_inds = np.argsort(np.max(np.abs(template1 + template2), axis=0))[::-1][:num_channels]
             else:
-                chan_inds = np.intersect1d(
-                    np.flatnonzero(sparsity_mask[unit_ind1]), np.flatnonzero(sparsity_mask[unit_ind2])
-                )
-
-            template1 = template1[:, chan_inds]
-            template2 = template2[:, chan_inds]
-
-            num_samples = template1.shape[0]
-            if template_metric == "l1":
-                norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
-            elif template_metric == "l2":
-                norm = np.sum(template1**2) + np.sum(template2**2)
-            elif template_metric == "cosine":
-                norm = np.linalg.norm(template1) * np.linalg.norm(template2)
-            all_shift_diff = []
-            for shift in range(-num_shift, num_shift + 1):
-                temp1 = template1[num_shift : num_samples - num_shift, :]
-                temp2 = template2[num_shift + shift : num_samples - num_shift + shift, :]
+                chan_inds = np.flatnonzero(sparsity_mask[unit_ind1] * sparsity_mask[unit_ind2])
+
+            if len(chan_inds) > 0:
+                template1 = template1[:, chan_inds]
+                template2 = template2[:, chan_inds]
+
+                num_samples = template1.shape[0]
                 if template_metric == "l1":
-                    d = np.sum(np.abs(temp1 - temp2)) / norm
+                    norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
                 elif template_metric == "l2":
-                    d = np.linalg.norm(temp1 - temp2) / norm
+                    norm = np.sum(template1**2) + np.sum(template2**2)
                 elif template_metric == "cosine":
-                    d = 1 - np.sum(temp1 * temp2) / norm
-                all_shift_diff.append(d)
+                    norm = np.linalg.norm(template1) * np.linalg.norm(template2)
+                all_shift_diff = []
+                for shift in all_shifts:
+                    temp1 = template1[num_shift : num_samples - num_shift, :]
+                    temp2 = template2[num_shift + shift : num_samples - num_shift + shift, :]
+                    if template_metric == "l1":
+                        d = np.sum(np.abs(temp1 - temp2)) / norm
+                    elif template_metric == "l2":
+                        d = np.linalg.norm(temp1 - temp2) / norm
+                    elif template_metric == "cosine":
+                        d = 1 - np.sum(temp1 * temp2) / norm
+                    all_shift_diff.append(d)
+            else:
+                all_shift_diff = [0]*len(all_shifts)
+                    
             templates_diff[unit_ind1, unit_ind2] = np.min(all_shift_diff)
 
     return templates_diff
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index da38e5ad15..7cb1b957ff 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -132,59 +132,59 @@ def plot_splitted_templates(self, case_key, pair_index=0):
             analyzer.compute(["spike_amplitudes"])
         plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
 
-    def visualize_splits(self, case_key, figsize=(15, 5)):
-        cc_similarities = []
-        from ..merging.drift import compute_presence_distance
-
-        analyzer = self.get_sorting_analyzer(case_key)
-        if analyzer.get_extension("template_similarity") is None:
-            analyzer.compute(["template_similarity"])
-
-        distances = {}
-        distances["similarity"] = analyzer.get_extension("template_similarity").get_data()
-        sorting = analyzer.sorting
-
-        distances["time_distance"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
-        for i, unit1 in enumerate(analyzer.unit_ids):
-            for j, unit2 in enumerate(analyzer.unit_ids):
-                if unit2 <= unit1:
-                    continue
-                d = compute_presence_distance(analyzer, unit1, unit2)
-                distances["time_distance"][i, j] = d
-
-        import lussac.utils as utils
-
-        distances["cross_cont"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
-        for i, unit1 in enumerate(analyzer.unit_ids):
-            for j, unit2 in enumerate(analyzer.unit_ids):
-                if unit2 <= unit1:
-                    continue
-                spike_train1 = np.array(sorting.get_unit_spike_train(unit1))
-                spike_train2 = np.array(sorting.get_unit_spike_train(unit2))
-                distances["cross_cont"][i, j], _ = utils.estimate_cross_contamination(
-                    spike_train1, spike_train2, (1, 4), limit=0.1
-                )
-
-        splits = np.array(self.benchmarks[case_key].splitted_cells)
-        src, tgt = splits[:, 0], splits[:, 1]
-        src = analyzer.sorting.ids_to_indices(src)
-        tgt = analyzer.sorting.ids_to_indices(tgt)
-        import matplotlib.pyplot as plt
-
-        fig, axs = plt.subplots(ncols=2, nrows=2, figsize=figsize, squeeze=True)
-        axs[0, 0].scatter(distances["similarity"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
-        axs[0, 0].scatter(distances["similarity"][src, tgt], distances["time_distance"][src, tgt], c="r")
-        axs[0, 0].set_xlabel("cc similarity")
-        axs[0, 0].set_ylabel("presence ratio")
-
-        axs[1, 0].scatter(distances["similarity"].flatten(), distances["cross_cont"].flatten(), c="k", alpha=0.25)
-        axs[1, 0].scatter(distances["similarity"][src, tgt], distances["cross_cont"][src, tgt], c="r")
-        axs[1, 0].set_xlabel("cc similarity")
-        axs[1, 0].set_ylabel("cross cont")
-
-        axs[0, 1].scatter(distances["cross_cont"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
-        axs[0, 1].scatter(distances["cross_cont"][src, tgt], distances["time_distance"][src, tgt], c="r")
-        axs[0, 1].set_xlabel("cross_cont")
-        axs[0, 1].set_ylabel("presence ratio")
-
-        plt.show()
+    # def visualize_splits(self, case_key, figsize=(15, 5)):
+    #     cc_similarities = []
+    #     from spikeinterface.curation. import compute_presence_distance
+
+    #     analyzer = self.get_sorting_analyzer(case_key)
+    #     if analyzer.get_extension("template_similarity") is None:
+    #         analyzer.compute(["template_similarity"])
+
+    #     distances = {}
+    #     distances["similarity"] = analyzer.get_extension("template_similarity").get_data()
+    #     sorting = analyzer.sorting
+
+    #     distances["time_distance"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+    #     for i, unit1 in enumerate(analyzer.unit_ids):
+    #         for j, unit2 in enumerate(analyzer.unit_ids):
+    #             if unit2 <= unit1:
+    #                 continue
+    #             d = compute_presence_distance(analyzer, unit1, unit2)
+    #             distances["time_distance"][i, j] = d
+
+    #     import lussac.utils as utils
+
+    #     distances["cross_cont"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
+    #     for i, unit1 in enumerate(analyzer.unit_ids):
+    #         for j, unit2 in enumerate(analyzer.unit_ids):
+    #             if unit2 <= unit1:
+    #                 continue
+    #             spike_train1 = np.array(sorting.get_unit_spike_train(unit1))
+    #             spike_train2 = np.array(sorting.get_unit_spike_train(unit2))
+    #             distances["cross_cont"][i, j], _ = utils.estimate_cross_contamination(
+    #                 spike_train1, spike_train2, (1, 4), limit=0.1
+    #             )
+
+    #     splits = np.array(self.benchmarks[case_key].splitted_cells)
+    #     src, tgt = splits[:, 0], splits[:, 1]
+    #     src = analyzer.sorting.ids_to_indices(src)
+    #     tgt = analyzer.sorting.ids_to_indices(tgt)
+    #     import matplotlib.pyplot as plt
+
+    #     fig, axs = plt.subplots(ncols=2, nrows=2, figsize=figsize, squeeze=True)
+    #     axs[0, 0].scatter(distances["similarity"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
+    #     axs[0, 0].scatter(distances["similarity"][src, tgt], distances["time_distance"][src, tgt], c="r")
+    #     axs[0, 0].set_xlabel("cc similarity")
+    #     axs[0, 0].set_ylabel("presence ratio")
+
+    #     axs[1, 0].scatter(distances["similarity"].flatten(), distances["cross_cont"].flatten(), c="k", alpha=0.25)
+    #     axs[1, 0].scatter(distances["similarity"][src, tgt], distances["cross_cont"][src, tgt], c="r")
+    #     axs[1, 0].set_xlabel("cc similarity")
+    #     axs[1, 0].set_ylabel("cross cont")
+
+    #     axs[0, 1].scatter(distances["cross_cont"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
+    #     axs[0, 1].scatter(distances["cross_cont"][src, tgt], distances["time_distance"][src, tgt], c="r")
+    #     axs[0, 1].set_xlabel("cross_cont")
+    #     axs[0, 1].set_ylabel("presence ratio")
+
+    #     plt.show()
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 9994955062..1da4aecb66 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -58,11 +58,11 @@ def run(self, extra_outputs=False):
             merges = get_potential_auto_merge(self.analyzer, **curation_kwargs)
         else:
             merges = []
-
+        print(len(merges))
         temporal_splits_kwargs = self.default_params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
             merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
-
+        print(len(merges))
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:

From 57749ba483fe31e8d7fad2067ec06e3b90bc641d Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 5 Jun 2024 07:29:12 +0000
Subject: [PATCH 045/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index d6917a6f41..d257f913d9 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -479,8 +479,8 @@ def compute_templates_diff(
                         d = 1 - np.sum(temp1 * temp2) / norm
                     all_shift_diff.append(d)
             else:
-                all_shift_diff = [0]*len(all_shifts)
-                    
+                all_shift_diff = [0] * len(all_shifts)
+
             templates_diff[unit_ind1, unit_ind2] = np.min(all_shift_diff)
 
     return templates_diff

From 82d021c1a5980d5634adbcca5c9eb39a3da8ae2b Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 11:08:45 +0200
Subject: [PATCH 046/164] Harmonize lussac and circus meta merging

---
 src/spikeinterface/curation/auto_merge.py     |   4 +-
 .../curation/merge_temporal_splits.py         |   6 +-
 src/spikeinterface/generation/drift_tools.py  |  17 +--
 .../sortingcomponents/merging/circus.py       |  25 ++--
 .../sortingcomponents/merging/lussac.py       | 112 ++++++++++++------
 5 files changed, 103 insertions(+), 61 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index d6917a6f41..46dcbd463c 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -61,7 +61,7 @@ def get_potential_auto_merge(
     ----------
     sorting_analyzer: SortingAnalyzer
         The SortingAnalyzer
-    minimum_spikes: int, default: 1000
+    minimum_spikes: int, default: 100
         Minimum number of spikes for each unit to consider a potential merge.
         Enough spikes are needed to estimate the correlogram
     maximum_distance_um: float, default: 150
@@ -479,7 +479,7 @@ def compute_templates_diff(
                         d = 1 - np.sum(temp1 * temp2) / norm
                     all_shift_diff.append(d)
             else:
-                all_shift_diff = [0]*len(all_shifts)
+                all_shift_diff = [1]*len(all_shifts)
                     
             templates_diff[unit_ind1, unit_ind2] = np.min(all_shift_diff)
 
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index ac455d6187..f8ae4c07a9 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -84,7 +84,7 @@ def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
     if pair_mask is None:
         pair_mask = np.ones((n, n), dtype="bool")
 
-    distances = np.ones((sorting.get_num_units(), sorting.get_num_units()))
+    presence_distances = np.ones((sorting.get_num_units(), sorting.get_num_units()))
 
     for unit_ind1 in range(n):
         for unit_ind2 in range(unit_ind1 + 1, n):
@@ -93,8 +93,8 @@ def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
             unit1 = unit_ids[unit_ind1]
             unit2 = unit_ids[unit_ind2]
             d = presence_distance(sorting, unit1, unit2, **presence_distance_kwargs)
-            distances[unit_ind1, unit_ind2] = d
-    presence_distances = np.triu(distances)
+            presence_distances[unit_ind1, unit_ind2] = d
+
     return presence_distances
 
 
diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index 93b391d5cc..98e30287e0 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -516,25 +516,27 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95):
+def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95, seed=None):
 
     if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
         sorting = sorting_or_sorting_analyzer.sorting
     else:
         sorting = sorting_or_sorting_analyzer
 
+    rng = np.random.RandomState(seed)
+
     sorting_split = sorting.select_units(sorting.unit_ids)
     split_units = []
     original_units = []
     nb_splits = int(splitting_probability * len(sorting.unit_ids))
-    to_split_ids = np.random.choice(sorting.unit_ids, nb_splits, replace=False)
+    to_split_ids = rng.choice(sorting.unit_ids, nb_splits, replace=False)
     import spikeinterface.curation as scur
 
     for unit in to_split_ids:
         num_spikes = len(sorting_split.get_unit_spike_train(unit))
         indices = np.zeros(num_spikes, dtype=int)
-        indices[: num_spikes // 2] = (np.random.rand(num_spikes // 2) < partial_split_prob).astype(int)
-        indices[num_spikes // 2 :] = (np.random.rand(num_spikes - num_spikes // 2) < 1 - partial_split_prob).astype(int)
+        indices[: num_spikes // 2] = (rng.rand(num_spikes // 2) < partial_split_prob).astype(int)
+        indices[num_spikes // 2 :] = (rng.rand(num_spikes - num_spikes // 2) < 1 - partial_split_prob).astype(int)
         sorting_split = scur.split_unit_sorting(
             sorting_split, split_unit_id=unit, indices_list=indices, properties_policy="remove"
         )
@@ -543,7 +545,7 @@ def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.
     return sorting_split, split_units
 
 
-def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
+def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5, seed=None):
     """
     Fonction used to split a sorting based on the amplitudes of the units. This
     might be used for benchmarking meta merging step (see components)
@@ -553,6 +555,7 @@ def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
         sorting_analyzer.compute("spike_amplitudes")
 
     sa = sorting_analyzer
+    rng = np.random.RandomState(seed)
 
     from spikeinterface.core.numpyextractors import NumpySorting
     from spikeinterface.core.template_tools import get_template_extremum_channel
@@ -562,7 +565,7 @@ def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
     new_spikes = spikes.copy()
     amplitudes = sa.get_extension("spike_amplitudes").get_data()
     nb_splits = int(splitting_probability * len(sa.sorting.unit_ids))
-    to_split_ids = np.random.choice(sa.sorting.unit_ids, nb_splits, replace=False)
+    to_split_ids = rng.choice(sa.sorting.unit_ids, nb_splits, replace=False)
     max_index = np.max(spikes["unit_index"])
     new_unit_ids = list(sa.sorting.unit_ids.copy())
     splitted_pairs = []
@@ -579,7 +582,7 @@ def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5):
 
         amplitude_mask = (amplitudes > m) * (amplitudes < thresh)
         mask = ind_mask & amplitude_mask
-        new_spikes["unit_index"][mask] = (max_index + 1) * np.random.rand(np.sum(mask)) > 0.5
+        new_spikes["unit_index"][mask] = (max_index + 1) * rng.rand(np.sum(mask)) > 0.5
         max_index += 1
         new_unit_ids += [max(new_unit_ids) + 1]
         splitted_pairs += [(unit_id, new_unit_ids[-1])]
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index c2f009ed76..4b7db20aeb 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,27 +16,30 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
+        "verbose" : False,
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
-            "num_channels": None,
-            "num_shift": 10,
+            "num_channels": 5,
+            "num_shift": 5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
             "template_metric": "cosine",
-            "num_channels": None,
-            "num_shift": 10,
+            "num_channels": 5,
+            "num_shift": 5,
         },
     }
 
     def __init__(self, recording, sorting, kwargs):
-        self.default_params.update(**kwargs)
+        self.params = self.default_params.copy()
+        self.params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.templates = self.default_params.pop("templates", None)
+        self.verbose = self.params.pop('verbose')
+        self.templates = self.params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -53,16 +56,18 @@ def __init__(self, recording, sorting, kwargs):
         # self.analyzer.compute(["template_similarity"], max_lag_ms=0.5, metric='cosine')
 
     def run(self, extra_outputs=False):
-        curation_kwargs = self.default_params.get("curation_kwargs", None)
+        curation_kwargs = self.params.get("curation_kwargs", None)
         if curation_kwargs is not None:
             merges = get_potential_auto_merge(self.analyzer, **curation_kwargs)
         else:
             merges = []
-        print(len(merges))
-        temporal_splits_kwargs = self.default_params.get("temporal_splits_kwargs", None)
+        if self.verbose:
+            print(f'{len(merges)} merges have been detected via auto merges')
+        temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
             merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
-        print(len(merges))
+            if self.verbose:
+                print(f'{len(merges)} merges have been detected via additional temporal splits')
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index a0aa2794b2..c062313749 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -229,13 +229,14 @@ def estimate_cross_contamination(
     return estimation, p_value
 
 
-def aurelien_merge(
+def lussac_merge(
     analyzer,
     refractory_period,
-    template_threshold: float = 0.2,
-    CC_threshold: float = 0.1,
-    max_shift: int = 10,
-    max_channels: int = 10,
+    minimum_spikes=100,
+    template_diff_thresh: float = 0.25,
+    CC_threshold: float = 0.2,
+    max_shift: int = 5,
+    num_channels: int = 5,
     template_metric="l1",
 ) -> list[tuple]:
     """
@@ -247,7 +248,9 @@ def aurelien_merge(
         The analyzer to look at
     refractory_period: array/list/tuple of 2 floats
         (censored_period_ms, refractory_period_ms)
-    template_threshold: float
+    minimum_spikes: int, default: 100
+        Minimum number of spikes for each unit to consider a potential merge.
+    template_diff_thresh: float
         The threshold on the template difference.
         Any pair above this threshold will not be considered.
     CC_treshold: float
@@ -262,55 +265,75 @@ def aurelien_merge(
     assert HAVE_NUMBA, "Numba should be installed"
     pairs = []
     sorting = analyzer.sorting
-    recording = analyzer.recording
     sf = analyzer.recording.sampling_frequency
     n_frames = analyzer.recording.get_num_samples()
+    sparsity = analyzer.sparsity
+    all_shifts = range(-max_shift, max_shift + 1)
+    unit_ids = sorting.unit_ids
 
-    for unit_id1 in analyzer.unit_ids:
-        for unit_id2 in analyzer.unit_ids:
-            if unit_id2 <= unit_id1:
-                continue
+    if sparsity is None:
+        adaptative_masks = False
+        sparsity_mask = None
+    else:
+        adaptative_masks = num_channels == None
+        sparsity_mask = sparsity.mask
+
+    for unit_ind1 in range(len(unit_ids)):
+        for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
+
+            unit_id1 = unit_ids[unit_ind1]
+            unit_id2 = unit_ids[unit_ind2]
 
+            # Checking that we have enough spikes
+            spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
+            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
+            if not (len(spike_train1) > minimum_spikes and len(spike_train2) > minimum_spikes):
+                continue
+            
             # Computing template difference
             template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
             template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
 
-            best_channel_indices = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][
-                :max_channels
-            ]
-
-            if template_metric == "l1":
-                norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
-            elif template_metric == "l2":
-                norm = np.sum(template1**2) + np.sum(template2**2)
-            elif template_metric == "cosine":
-                norm = np.linalg.norm(template1) * np.linalg.norm(template2)
-
-            all_shift_diff = []
-            n = len(template1)
-            for shift in range(-max_shift, max_shift + 1):
-                temp1 = template1[max_shift : n - max_shift, best_channel_indices]
-                temp2 = template2[max_shift + shift : n - max_shift + shift, best_channel_indices]
+            if not adaptative_masks:
+                chan_inds = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:num_channels]
+            else:
+                chan_inds = np.flatnonzero(sparsity_mask[unit_ind1] * sparsity_mask[unit_ind2])
+
+            if len(chan_inds) > 0:
+                template1 = template1[:, chan_inds]
+                template2 = template2[:, chan_inds]
+
                 if template_metric == "l1":
-                    d = np.sum(np.abs(temp1 - temp2)) / norm
+                    norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
                 elif template_metric == "l2":
-                    d = np.linalg.norm(temp1 - temp2) / norm
+                    norm = np.sum(template1**2) + np.sum(template2**2)
                 elif template_metric == "cosine":
-                    d = 1 - np.sum(temp1 * temp2) / norm
-                all_shift_diff.append(d)
+                    norm = np.linalg.norm(template1) * np.linalg.norm(template2)
+
+                all_shift_diff = []
+                n = len(template1)
+                for shift in all_shifts:
+                    temp1 = template1[max_shift : n - max_shift, :]
+                    temp2 = template2[max_shift + shift : n - max_shift + shift, :]
+                    if template_metric == "l1":
+                        d = np.sum(np.abs(temp1 - temp2)) / norm
+                    elif template_metric == "l2":
+                        d = np.linalg.norm(temp1 - temp2) / norm
+                    elif template_metric == "cosine":
+                        d = 1 - np.sum(temp1 * temp2) / norm
+                    all_shift_diff.append(d)
+            else:
+                all_shift_diff = [1]*len(all_shifts)
 
             max_diff = np.min(all_shift_diff)
 
-            if max_diff > template_threshold:
+            if max_diff > template_diff_thresh:
                 continue
 
             # Compuyting the cross-contamination difference
-            spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
-            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
             CC, p_value = estimate_cross_contamination(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
-
             if p_value < 0.2:
                 continue
 
@@ -324,13 +347,22 @@ class LussacMerging(BaseMergingEngine):
     Meta merging inspired from the Lussac metric
     """
 
-    default_params = {"templates": None, "refractory_period": (0.4, 1.9)}
+    default_params = {
+        "templates": None, 
+        "minimum_spikes" : 50,
+        "refractory_period": (0.4, 1.9),
+        "template_metric": "cosine",
+        "num_channels": 5,
+        "verbose" : False
+        }
 
     def __init__(self, recording, sorting, kwargs):
-        self.default_params.update(**kwargs)
+        self.params = self.default_params.copy()
+        self.params.update(**kwargs)
         self.sorting = sorting
+        self.verbose = self.params.pop('verbose')
         self.recording = recording
-        self.templates = self.default_params.pop("templates", None)
+        self.templates = self.params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -345,7 +377,9 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
     def run(self, extra_outputs=False):
-        merges = aurelien_merge(self.analyzer, **self.default_params)
+        merges = lussac_merge(self.analyzer, **self.params)
+        if self.verbose:
+            print(f"{len(merges)} merges have been detected")
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:

From 3f9f84c49ae1c17db6b9cfd956c9f27edd2bd5cc Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 11:46:09 +0200
Subject: [PATCH 047/164] Exploring params

---
 .../curation/merge_temporal_splits.py          | 18 +++++++++---------
 .../sortingcomponents/merging/circus.py        |  4 ++--
 .../sortingcomponents/merging/lussac.py        |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index f8ae4c07a9..af88b8ad43 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -203,15 +203,15 @@ def get_potential_temporal_splits(
         pair_mask = pair_mask & (presence_distances < presence_distance_threshold)
 
     # STEP 4 : validate the potential merges with CC increase the contamination quality metrics
-    if "check_increase_score" in steps:
-        pair_mask, pairs_decreased_score = check_improve_contaminations_score(
-            sorting_analyzer,
-            pair_mask,
-            contaminations,
-            firing_contamination_balance,
-            refractory_period_ms,
-            censored_period_ms,
-        )
+    # if "check_increase_score" in steps:
+    #     pair_mask, pairs_decreased_score = check_improve_contaminations_score(
+    #         sorting_analyzer,
+    #         pair_mask,
+    #         contaminations,
+    #         firing_contamination_balance,
+    #         refractory_period_ms,
+    #         censored_period_ms,
+    #     )
 
     # FINAL STEP : create the final list from pair_mask boolean matrix
     ind1, ind2 = np.nonzero(pair_mask)
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4b7db20aeb..2e3b96dab6 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -20,14 +20,14 @@ class CircusMerging(BaseMergingEngine):
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
-            "template_metric": "cosine",
+            "template_metric": "l1",
             "num_channels": 5,
             "num_shift": 5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
-            "template_metric": "cosine",
+            "template_metric": "l1",
             "num_channels": 5,
             "num_shift": 5,
         },
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index c062313749..1eebdfbf9a 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -351,7 +351,7 @@ class LussacMerging(BaseMergingEngine):
         "templates": None, 
         "minimum_spikes" : 50,
         "refractory_period": (0.4, 1.9),
-        "template_metric": "cosine",
+        "template_metric": "l1",
         "num_channels": 5,
         "verbose" : False
         }

From ba459c65003e0bb3df4ffa29289a488ddb0c783c Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 12:19:19 +0200
Subject: [PATCH 048/164] Params

---
 .../curation/merge_temporal_splits.py          | 18 +++++++++---------
 .../sortingcomponents/merging/circus.py        |  4 +++-
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index af88b8ad43..f8ae4c07a9 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -203,15 +203,15 @@ def get_potential_temporal_splits(
         pair_mask = pair_mask & (presence_distances < presence_distance_threshold)
 
     # STEP 4 : validate the potential merges with CC increase the contamination quality metrics
-    # if "check_increase_score" in steps:
-    #     pair_mask, pairs_decreased_score = check_improve_contaminations_score(
-    #         sorting_analyzer,
-    #         pair_mask,
-    #         contaminations,
-    #         firing_contamination_balance,
-    #         refractory_period_ms,
-    #         censored_period_ms,
-    #     )
+    if "check_increase_score" in steps:
+        pair_mask, pairs_decreased_score = check_improve_contaminations_score(
+            sorting_analyzer,
+            pair_mask,
+            contaminations,
+            firing_contamination_balance,
+            refractory_period_ms,
+            censored_period_ms,
+        )
 
     # FINAL STEP : create the final list from pair_mask boolean matrix
     ind1, ind2 = np.nonzero(pair_mask)
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 2e3b96dab6..7a453049ae 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -20,13 +20,15 @@ class CircusMerging(BaseMergingEngine):
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
-            "template_metric": "l1",
+            "template_metric": "cosine",
+            "firing_contamination_balance" : 0.5,
             "num_channels": 5,
             "num_shift": 5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
+            "firing_contamination_balance" : 0.5,
             "template_metric": "l1",
             "num_channels": 5,
             "num_shift": 5,

From 283aae92fbdbc918ffdb7d1fc47ab80fae6b535d Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 5 Jun 2024 12:41:00 +0000
Subject: [PATCH 049/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py          |  2 +-
 .../sortingcomponents/merging/circus.py            | 12 ++++++------
 .../sortingcomponents/merging/lussac.py            | 14 +++++++-------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 6d7e3d59e3..b782792b26 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -480,7 +480,7 @@ def compute_templates_diff(
                     all_shift_diff.append(d)
             else:
                 all_shift_diff = [1] * len(all_shifts)
-                    
+
             templates_diff[unit_ind1, unit_ind2] = np.min(all_shift_diff)
 
     return templates_diff
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 7a453049ae..4486b9faf6 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,19 +16,19 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose" : False,
+        "verbose": False,
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
-            "firing_contamination_balance" : 0.5,
+            "firing_contamination_balance": 0.5,
             "num_channels": 5,
             "num_shift": 5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
-            "firing_contamination_balance" : 0.5,
+            "firing_contamination_balance": 0.5,
             "template_metric": "l1",
             "num_channels": 5,
             "num_shift": 5,
@@ -40,7 +40,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.verbose = self.params.pop('verbose')
+        self.verbose = self.params.pop("verbose")
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
@@ -64,12 +64,12 @@ def run(self, extra_outputs=False):
         else:
             merges = []
         if self.verbose:
-            print(f'{len(merges)} merges have been detected via auto merges')
+            print(f"{len(merges)} merges have been detected via auto merges")
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
             merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
             if self.verbose:
-                print(f'{len(merges)} merges have been detected via additional temporal splits')
+                print(f"{len(merges)} merges have been detected via additional temporal splits")
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 1eebdfbf9a..09a690bfee 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -289,7 +289,7 @@ def lussac_merge(
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
             if not (len(spike_train1) > minimum_spikes and len(spike_train2) > minimum_spikes):
                 continue
-            
+
             # Computing template difference
             template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
             template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
@@ -323,7 +323,7 @@ def lussac_merge(
                         d = 1 - np.sum(temp1 * temp2) / norm
                     all_shift_diff.append(d)
             else:
-                all_shift_diff = [1]*len(all_shifts)
+                all_shift_diff = [1] * len(all_shifts)
 
             max_diff = np.min(all_shift_diff)
 
@@ -348,19 +348,19 @@ class LussacMerging(BaseMergingEngine):
     """
 
     default_params = {
-        "templates": None, 
-        "minimum_spikes" : 50,
+        "templates": None,
+        "minimum_spikes": 50,
         "refractory_period": (0.4, 1.9),
         "template_metric": "l1",
         "num_channels": 5,
-        "verbose" : False
-        }
+        "verbose": False,
+    }
 
     def __init__(self, recording, sorting, kwargs):
         self.params = self.default_params.copy()
         self.params.update(**kwargs)
         self.sorting = sorting
-        self.verbose = self.params.pop('verbose')
+        self.verbose = self.params.pop("verbose")
         self.recording = recording
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:

From 0bde7bb49118baed18dfe3448c96dea9f188ab5c Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 14:41:02 +0200
Subject: [PATCH 050/164] Docs

---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 6d7e3d59e3..4171a8a035 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -61,7 +61,7 @@ def get_potential_auto_merge(
     ----------
     sorting_analyzer : SortingAnalyzer
         The SortingAnalyzer
-    minimum_spikes: int, default: 100
+    minimum_spikes : int, default: 100
         Minimum number of spikes for each unit to consider a potential merge.
         Enough spikes are needed to estimate the correlogram
     maximum_distance_um : float, default: 150

From 86e73e1c7a0a9ec96266a300618c3480a181d84e Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 14:42:42 +0200
Subject: [PATCH 051/164] Docs

---
 .../sortingcomponents/merging/lussac.py       | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 09a690bfee..e64b40cddb 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -21,13 +21,13 @@ def binom_sf(x: int, n: float, p: float) -> float:
     From values where the cdf is really close to 1.0, the survival function gives more precise results.
     Allows for a non-integer n (uses interpolation).
 
-    @param x: int
+    @param x : int
         The number of successes.
-    @param n: float
+    @param n : float
         The number of trials.
     @param p: float
         The probability of success.
-    @return sf: float
+    @return sf : float
         The survival function of the binomial distribution.
     """
 
@@ -49,7 +49,7 @@ def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
         """
         Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
 
-        @param max_time: float
+        @param max_time : float
             The maximum time between 2 spikes to be considered as a coincidence.
         @return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
             The borders and their probabilities.
@@ -70,11 +70,11 @@ def compute_nb_violations(spike_train, max_time) -> float:
         """
         Computes the number of refractory period violations in a spike train.
 
-        @param spike_train: array[int64] (n_spikes)
+        @param spike_train : array[int64] (n_spikes)
             The spike train to compute the number of violations for.
-        @param max_time: float32
+        @param max_time : float32
             The maximum time to consider for violations (in number of samples).
-        @return n_violations: float
+        @return n_violations : float
             The number of spike pairs that violate the refractory period.
         """
 
@@ -112,13 +112,13 @@ def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
         f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
         where x is the distance between max_time floor/ceil(max_time)
 
-        @param spike_train1: array[int64] (n_spikes1)
+        @param spike_train1 : array[int64] (n_spikes1)
             The spike train of the first unit.
-        @param spike_train2: array[int64] (n_spikes2)
+        @param spike_train2 : array[int64] (n_spikes2)
             The spike train of the second unit.
-        @param max_time: float32
+        @param max_time : float32
             The maximum time to consider for coincidence (in number samples).
-        @return n_coincidence: float
+        @return n_coincidence : float
             The number of coincident spikes.
         """
 
@@ -157,11 +157,11 @@ def estimate_contamination(spike_train: np.ndarray, sf: float, T: int, refractor
     uncorrelated to the neuron. Under this assumption, we can estimate the contamination (i.e. the
     fraction of noisy spikes to the total number of spikes).
 
-    @param spike_train: np.ndarray
+    @param spike_train : np.ndarray
         The unit's spike train.
-    @param refractory_period: tuple[float, float]
+    @param refractory_period : tuple[float, float]
         The censored and refractory period (t_c, t_r) used (in ms).
-    @return estimated_contamination: float
+    @return estimated_contamination : float
         The estimated contamination between 0 and 1.
     """
 
@@ -188,15 +188,15 @@ def estimate_cross_contamination(
     Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
     Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
 
-    @param spike_train1: np.ndarray
+    @param spike_train1 : np.ndarray
         The spike train of the first unit.
-    @param spike_train2: np.ndarray
+    @param spike_train2 : np.ndarray
         The spike train of the second unit.
-    @param refractory_period: tuple[float, float]
+    @param refractory_period : tuple[float, float]
         The censored and refractory period (t_c, t_r) used (in ms).
-    @param limit: float | None
+    @param limit : float | None
         The higher limit of cross-contamination for the statistical test.
-    @return (estimated_cross_cont, p_value): tuple[float, float] if limit is not None
+    @return (estimated_cross_cont, p_value) : tuple[float, float] if limit is not None
             estimated_cross_cont: float if limit is None
         Returns the estimation of cross-contamination, as well as the p-value of the statistical test if the limit is given.
     """
@@ -244,21 +244,21 @@ def lussac_merge(
 
     Parameters
     ----------
-    analyzer: SortingAnalyzer
+    analyzer : SortingAnalyzer
         The analyzer to look at
-    refractory_period: array/list/tuple of 2 floats
+    refractory_period : array/list/tuple of 2 floats
         (censored_period_ms, refractory_period_ms)
-    minimum_spikes: int, default: 100
+    minimum_spikes : int, default: 100
         Minimum number of spikes for each unit to consider a potential merge.
-    template_diff_thresh: float
+    template_diff_thresh : float
         The threshold on the template difference.
         Any pair above this threshold will not be considered.
-    CC_treshold: float
+    CC_treshold : float
         The threshold on the cross-contamination.
         Any pair above this threshold will not be considered.
-    max_shift: int
+    max_shift : int
         The maximum shift when comparing the templates (in number of time samples).
-    max_channels: int
+    max_channels : int
         The maximum number of channels to consider when comparing the templates.
     """
 

From 88c1bc89e8c06c8668be9371869e18452332b4cb Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 14:59:24 +0200
Subject: [PATCH 052/164] Reuse the templates already available

---
 .../sorters/internal/spyking_circus2.py              |  2 +-
 .../sortingcomponents/merging/circus.py              | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index fae0a789f0..dd41943486 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -325,7 +325,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 sorting.save(folder=curation_folder)
                 # np.save(fitting_folder / "amplitudes", guessed_amplitudes)
 
-            merging_params["templates"] = templates
+            merging_params["method_kwargs"] = {"templates" : templates}
             sorting = merge_spikes(recording_w, sorting, **merging_params)
 
             if verbose:
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4486b9faf6..7a453049ae 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,19 +16,19 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose": False,
+        "verbose" : False,
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
-            "firing_contamination_balance": 0.5,
+            "firing_contamination_balance" : 0.5,
             "num_channels": 5,
             "num_shift": 5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
-            "firing_contamination_balance": 0.5,
+            "firing_contamination_balance" : 0.5,
             "template_metric": "l1",
             "num_channels": 5,
             "num_shift": 5,
@@ -40,7 +40,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.verbose = self.params.pop("verbose")
+        self.verbose = self.params.pop('verbose')
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
@@ -64,12 +64,12 @@ def run(self, extra_outputs=False):
         else:
             merges = []
         if self.verbose:
-            print(f"{len(merges)} merges have been detected via auto merges")
+            print(f'{len(merges)} merges have been detected via auto merges')
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
             merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
             if self.verbose:
-                print(f"{len(merges)} merges have been detected via additional temporal splits")
+                print(f'{len(merges)} merges have been detected via additional temporal splits')
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:

From 9195a75ffb73a5cf1764beea270ced210a0f6702 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 5 Jun 2024 12:59:53 +0000
Subject: [PATCH 053/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sorters/internal/spyking_circus2.py              |  2 +-
 .../sortingcomponents/merging/circus.py              | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index dd41943486..461525579b 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -325,7 +325,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 sorting.save(folder=curation_folder)
                 # np.save(fitting_folder / "amplitudes", guessed_amplitudes)
 
-            merging_params["method_kwargs"] = {"templates" : templates}
+            merging_params["method_kwargs"] = {"templates": templates}
             sorting = merge_spikes(recording_w, sorting, **merging_params)
 
             if verbose:
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 7a453049ae..4486b9faf6 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,19 +16,19 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose" : False,
+        "verbose": False,
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "template_metric": "cosine",
-            "firing_contamination_balance" : 0.5,
+            "firing_contamination_balance": 0.5,
             "num_channels": 5,
             "num_shift": 5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "presence_distance_threshold": 0.1,
-            "firing_contamination_balance" : 0.5,
+            "firing_contamination_balance": 0.5,
             "template_metric": "l1",
             "num_channels": 5,
             "num_shift": 5,
@@ -40,7 +40,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.verbose = self.params.pop('verbose')
+        self.verbose = self.params.pop("verbose")
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
             sparsity = self.templates.sparsity
@@ -64,12 +64,12 @@ def run(self, extra_outputs=False):
         else:
             merges = []
         if self.verbose:
-            print(f'{len(merges)} merges have been detected via auto merges')
+            print(f"{len(merges)} merges have been detected via auto merges")
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
             merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
             if self.verbose:
-                print(f'{len(merges)} merges have been detected via additional temporal splits')
+                print(f"{len(merges)} merges have been detected via additional temporal splits")
         merges = resolve_merging_graph(self.sorting, merges)
         sorting = apply_merges_to_sorting(self.sorting, merges)
         if extra_outputs:

From b7f54d7046ef6e61185f47c4c835cbd1fe336c73 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 20:42:17 +0200
Subject: [PATCH 054/164] Harmonize params

---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index e64b40cddb..4322de114f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -350,7 +350,7 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "minimum_spikes": 50,
-        "refractory_period": (0.4, 1.9),
+        "refractory_period": (0.3, 1.0),
         "template_metric": "l1",
         "num_channels": 5,
         "verbose": False,

From 9d8a699324233e451105da30ad48715713375277 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 5 Jun 2024 21:03:30 +0200
Subject: [PATCH 055/164] Adding possibility to only split cells given SNR

---
 src/spikeinterface/generation/drift_tools.py | 60 +++++++++++++++-----
 1 file changed, 46 insertions(+), 14 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index 2e58cdde4c..df2f1ed729 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -516,22 +516,36 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95, seed=None):
-
-    if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
-        sorting = sorting_or_sorting_analyzer.sorting
-    else:
-        sorting = sorting_or_sorting_analyzer
-
+def split_sorting_by_times(sorting_analyzer, 
+                           splitting_probability=0.5, 
+                           partial_split_prob=0.95, 
+                           unit_ids=None,
+                           min_snr=None,
+                           seed=None):
+    sa = sorting_analyzer
+    sorting = sa.sorting
     rng = np.random.RandomState(seed)
 
     sorting_split = sorting.select_units(sorting.unit_ids)
     split_units = []
     original_units = []
     nb_splits = int(splitting_probability * len(sorting.unit_ids))
-    to_split_ids = rng.choice(sorting.unit_ids, nb_splits, replace=False)
-    import spikeinterface.curation as scur
+    if unit_ids is None:
+        select_from = sorting.unit_ids
+        if min_snr is not None:
+            if sa.get_extension("noise_levels") is None:
+                sa.compute("noise_levels")
+            if sa.get_extension("quality_metrics") is None:
+                sa.compute('quality_metrics', metric_names=['snr'])
+            
+            snr = sa.get_extension('quality_metrics').get_data()['snr'].values
+            select_from = select_from[snr > min_snr]
+    
+        to_split_ids = rng.choice(select_from, nb_splits, replace=False)
+    else:
+        to_split_ids = unit_ids
 
+    import spikeinterface.curation as scur
     for unit in to_split_ids:
         num_spikes = len(sorting_split.get_unit_spike_train(unit))
         indices = np.zeros(num_spikes, dtype=int)
@@ -545,16 +559,20 @@ def split_sorting_by_times(sorting_or_sorting_analyzer, splitting_probability=0.
     return sorting_split, split_units
 
 
-def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5, seed=None):
+def split_sorting_by_amplitudes(sorting_analyzer, 
+                                splitting_probability=0.5, 
+                                unit_ids=None,
+                                min_snr=None,
+                                seed=None):
     """
     Fonction used to split a sorting based on the amplitudes of the units. This
     might be used for benchmarking meta merging step (see components)
     """
 
-    if sorting_analyzer.get_extension("spike_amplitudes") is None:
-        sorting_analyzer.compute("spike_amplitudes")
-
     sa = sorting_analyzer
+    if sa.get_extension("spike_amplitudes") is None:
+        sa.compute("spike_amplitudes")
+
     rng = np.random.RandomState(seed)
 
     from spikeinterface.core.numpyextractors import NumpySorting
@@ -565,7 +583,21 @@ def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5, see
     new_spikes = spikes.copy()
     amplitudes = sa.get_extension("spike_amplitudes").get_data()
     nb_splits = int(splitting_probability * len(sa.sorting.unit_ids))
-    to_split_ids = rng.choice(sa.sorting.unit_ids, nb_splits, replace=False)
+
+    if unit_ids is None:
+        select_from = sa.sorting.unit_ids
+        if min_snr is not None:
+            if sa.get_extension("noise_levels") is None:
+                sa.compute("noise_levels")
+            if sa.get_extension("quality_metrics") is None:
+                sa.compute('quality_metrics', metric_names=['snr'])
+            
+            snr = sa.get_extension('quality_metrics').get_data()['snr'].values
+            select_from = select_from[snr > min_snr]
+        to_split_ids = rng.choice(select_from, nb_splits, replace=False)
+    else:
+        to_split_ids = unit_ids
+
     max_index = np.max(spikes["unit_index"])
     new_unit_ids = list(sa.sorting.unit_ids.copy())
     splitted_pairs = []

From 00f0a9f058ddf93363852a874772d9fe40729077 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 5 Jun 2024 19:04:22 +0000
Subject: [PATCH 056/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/generation/drift_tools.py | 30 ++++++++------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/spikeinterface/generation/drift_tools.py b/src/spikeinterface/generation/drift_tools.py
index df2f1ed729..a41d5f5670 100644
--- a/src/spikeinterface/generation/drift_tools.py
+++ b/src/spikeinterface/generation/drift_tools.py
@@ -516,12 +516,9 @@ def get_num_samples(self) -> int:
         return self.num_samples
 
 
-def split_sorting_by_times(sorting_analyzer, 
-                           splitting_probability=0.5, 
-                           partial_split_prob=0.95, 
-                           unit_ids=None,
-                           min_snr=None,
-                           seed=None):
+def split_sorting_by_times(
+    sorting_analyzer, splitting_probability=0.5, partial_split_prob=0.95, unit_ids=None, min_snr=None, seed=None
+):
     sa = sorting_analyzer
     sorting = sa.sorting
     rng = np.random.RandomState(seed)
@@ -536,16 +533,17 @@ def split_sorting_by_times(sorting_analyzer,
             if sa.get_extension("noise_levels") is None:
                 sa.compute("noise_levels")
             if sa.get_extension("quality_metrics") is None:
-                sa.compute('quality_metrics', metric_names=['snr'])
-            
-            snr = sa.get_extension('quality_metrics').get_data()['snr'].values
+                sa.compute("quality_metrics", metric_names=["snr"])
+
+            snr = sa.get_extension("quality_metrics").get_data()["snr"].values
             select_from = select_from[snr > min_snr]
-    
+
         to_split_ids = rng.choice(select_from, nb_splits, replace=False)
     else:
         to_split_ids = unit_ids
 
     import spikeinterface.curation as scur
+
     for unit in to_split_ids:
         num_spikes = len(sorting_split.get_unit_spike_train(unit))
         indices = np.zeros(num_spikes, dtype=int)
@@ -559,11 +557,7 @@ def split_sorting_by_times(sorting_analyzer,
     return sorting_split, split_units
 
 
-def split_sorting_by_amplitudes(sorting_analyzer, 
-                                splitting_probability=0.5, 
-                                unit_ids=None,
-                                min_snr=None,
-                                seed=None):
+def split_sorting_by_amplitudes(sorting_analyzer, splitting_probability=0.5, unit_ids=None, min_snr=None, seed=None):
     """
     Fonction used to split a sorting based on the amplitudes of the units. This
     might be used for benchmarking meta merging step (see components)
@@ -590,9 +584,9 @@ def split_sorting_by_amplitudes(sorting_analyzer,
             if sa.get_extension("noise_levels") is None:
                 sa.compute("noise_levels")
             if sa.get_extension("quality_metrics") is None:
-                sa.compute('quality_metrics', metric_names=['snr'])
-            
-            snr = sa.get_extension('quality_metrics').get_data()['snr'].values
+                sa.compute("quality_metrics", metric_names=["snr"])
+
+            snr = sa.get_extension("quality_metrics").get_data()["snr"].values
             select_from = select_from[snr > min_snr]
         to_split_ids = rng.choice(select_from, nb_splits, replace=False)
     else:

From 30a7d3659cfd38d1b83d5ccef6a759d947731515 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 8 Jun 2024 20:01:51 +0000
Subject: [PATCH 057/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index e72fdf9e31..6db42e9aca 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -17,6 +17,7 @@
 from spikeinterface.core.basesorting import minimum_spike_dtype
 from spikeinterface.core.sparsity import compute_sparsity
 
+
 class Spykingcircus2Sorter(ComponentsBasedSorter):
     sorter_name = "spykingcircus2"
 

From 3c0bb8626bda7b1f00bb91bb5ee4cebcb9212058 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Sat, 8 Jun 2024 22:11:49 +0200
Subject: [PATCH 058/164] Handling precomputed similarities for curation

---
 src/spikeinterface/curation/auto_merge.py     | 26 +++++++++++--------
 .../curation/merge_temporal_splits.py         | 26 +++++++++++--------
 .../sortingcomponents/merging/circus.py       |  2 +-
 3 files changed, 31 insertions(+), 23 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index c633ba1aab..9b85b60593 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -206,17 +206,21 @@ def get_potential_auto_merge(
             templates_ext is not None
         ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
 
-        templates_array = templates_ext.get_data(outputs="numpy")
-
-        templates_diff = compute_templates_diff(
-            sorting,
-            templates_array,
-            num_channels=num_channels,
-            num_shift=num_shift,
-            pair_mask=pair_mask,
-            template_metric=template_metric,
-            sparsity=sorting_analyzer.sparsity,
-        )
+        template_similarity_ext = sorting_analyzer.get_extension('template_similarity')
+        if template_similarity_ext is not None:
+            templates_diff = template_similarity_ext.get_data()
+        else:
+            templates_array = templates_ext.get_data(outputs="numpy")
+
+            templates_diff = compute_templates_diff(
+                sorting,
+                templates_array,
+                num_channels=num_channels,
+                num_shift=num_shift,
+                pair_mask=pair_mask,
+                template_metric=template_metric,
+                sparsity=sorting_analyzer.sparsity,
+            )
 
         pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index f8ae4c07a9..b2156be8ed 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -183,17 +183,21 @@ def get_potential_temporal_splits(
             templates_ext is not None
         ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
 
-        templates_array = templates_ext.get_data(outputs="numpy")
-
-        templates_diff = compute_templates_diff(
-            sorting,
-            templates_array,
-            num_channels=num_channels,
-            num_shift=num_shift,
-            pair_mask=pair_mask,
-            template_metric=template_metric,
-            sparsity=sorting_analyzer.sparsity,
-        )
+        template_similarity_ext = sorting_analyzer.get_extension('template_similarity')
+        if template_similarity_ext is not None:
+            templates_diff = template_similarity_ext.get_data()
+        else:
+            templates_array = templates_ext.get_data(outputs="numpy")
+
+            templates_diff = compute_templates_diff(
+                sorting,
+                templates_array,
+                num_channels=num_channels,
+                num_shift=num_shift,
+                pair_mask=pair_mask,
+                template_metric=template_metric,
+                sparsity=sorting_analyzer.sparsity,
+            )
 
         pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4486b9faf6..481301c1fa 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -55,7 +55,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        # self.analyzer.compute(["template_similarity"], max_lag_ms=0.5, metric='cosine')
+        self.analyzer.compute("template_similarity")
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.params.get("curation_kwargs", None)

From 5ff19a14740292e8793a5552d6ed800a35a6436f Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 8 Jun 2024 20:12:20 +0000
Subject: [PATCH 059/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py            | 2 +-
 src/spikeinterface/curation/merge_temporal_splits.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 9b85b60593..575fcdb156 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -206,7 +206,7 @@ def get_potential_auto_merge(
             templates_ext is not None
         ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
 
-        template_similarity_ext = sorting_analyzer.get_extension('template_similarity')
+        template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
         if template_similarity_ext is not None:
             templates_diff = template_similarity_ext.get_data()
         else:
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index b2156be8ed..fbd253047f 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -183,7 +183,7 @@ def get_potential_temporal_splits(
             templates_ext is not None
         ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
 
-        template_similarity_ext = sorting_analyzer.get_extension('template_similarity')
+        template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
         if template_similarity_ext is not None:
             templates_diff = template_similarity_ext.get_data()
         else:

From b0dab64c397ff566832e36cedba9722551f94e5a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Sun, 9 Jun 2024 15:11:30 +0200
Subject: [PATCH 060/164] Prepare for the use of template_similarity instead

---
 src/spikeinterface/curation/auto_merge.py            | 6 ++++--
 src/spikeinterface/curation/merge_temporal_splits.py | 5 +++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 575fcdb156..c754fc17d8 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -208,7 +208,9 @@ def get_potential_auto_merge(
 
         template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
         if template_similarity_ext is not None:
-            templates_diff = template_similarity_ext.get_data()
+            templates_similarity = template_similarity_ext.get_data()
+            pair_mask = pair_mask & (templates_similarity > (1 - template_diff_thresh))
+
         else:
             templates_array = templates_ext.get_data(outputs="numpy")
 
@@ -222,7 +224,7 @@ def get_potential_auto_merge(
                 sparsity=sorting_analyzer.sparsity,
             )
 
-        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
     # STEP 6 : validate the potential merges with CC increase the contamination quality metrics
     if "check_increase_score" in steps:
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index fbd253047f..45f38421cd 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -185,7 +185,8 @@ def get_potential_temporal_splits(
 
         template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
         if template_similarity_ext is not None:
-            templates_diff = template_similarity_ext.get_data()
+            templates_similarity = template_similarity_ext.get_data()
+            pair_mask = pair_mask & (templates_similarity > (1 - template_diff_thresh))
         else:
             templates_array = templates_ext.get_data(outputs="numpy")
 
@@ -199,7 +200,7 @@ def get_potential_temporal_splits(
                 sparsity=sorting_analyzer.sparsity,
             )
 
-        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
     # STEP 3 : validate the potential merges with CC increase the contamination quality metrics
     if "presence_distance" in steps:

From 7f3d365fa963bb94c1fb1eb3355c88b23b5d53da Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 10 Jun 2024 09:35:17 +0200
Subject: [PATCH 061/164] WIP to integrate Alessio's widget

---
 .../benchmark/benchmark_merging.py            | 83 ++++++-------------
 1 file changed, 26 insertions(+), 57 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 7cb1b957ff..830a086289 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -106,7 +106,6 @@ def plot_agreements(self, case_keys=None, figsize=(15, 15)):
 
     def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
         from spikeinterface.widgets.widget_list import plot_study_unit_counts
-
         plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
 
     def get_splitted_pairs(self, case_key):
@@ -131,60 +130,30 @@ def plot_splitted_templates(self, case_key, pair_index=0):
         if analyzer.get_extension("spike_amplitudes") is None:
             analyzer.compute(["spike_amplitudes"])
         plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
+    
+    def plot_potential_merges(self, case_key, min_snr=None):
+        analyzer = self.get_sorting_analyzer(case_key)
+        mylist = self.get_splitted_pairs(case_key)
+
+        if analyzer.get_extension("spike_amplitudes") is None:
+            analyzer.compute(["spike_amplitudes"])
+        if analyzer.get_extension("correlograms") is None:
+            analyzer.compute(["correlograms"])
 
-    # def visualize_splits(self, case_key, figsize=(15, 5)):
-    #     cc_similarities = []
-    #     from spikeinterface.curation. import compute_presence_distance
-
-    #     analyzer = self.get_sorting_analyzer(case_key)
-    #     if analyzer.get_extension("template_similarity") is None:
-    #         analyzer.compute(["template_similarity"])
-
-    #     distances = {}
-    #     distances["similarity"] = analyzer.get_extension("template_similarity").get_data()
-    #     sorting = analyzer.sorting
-
-    #     distances["time_distance"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
-    #     for i, unit1 in enumerate(analyzer.unit_ids):
-    #         for j, unit2 in enumerate(analyzer.unit_ids):
-    #             if unit2 <= unit1:
-    #                 continue
-    #             d = compute_presence_distance(analyzer, unit1, unit2)
-    #             distances["time_distance"][i, j] = d
-
-    #     import lussac.utils as utils
-
-    #     distances["cross_cont"] = np.ones((analyzer.get_num_units(), analyzer.get_num_units()))
-    #     for i, unit1 in enumerate(analyzer.unit_ids):
-    #         for j, unit2 in enumerate(analyzer.unit_ids):
-    #             if unit2 <= unit1:
-    #                 continue
-    #             spike_train1 = np.array(sorting.get_unit_spike_train(unit1))
-    #             spike_train2 = np.array(sorting.get_unit_spike_train(unit2))
-    #             distances["cross_cont"][i, j], _ = utils.estimate_cross_contamination(
-    #                 spike_train1, spike_train2, (1, 4), limit=0.1
-    #             )
-
-    #     splits = np.array(self.benchmarks[case_key].splitted_cells)
-    #     src, tgt = splits[:, 0], splits[:, 1]
-    #     src = analyzer.sorting.ids_to_indices(src)
-    #     tgt = analyzer.sorting.ids_to_indices(tgt)
-    #     import matplotlib.pyplot as plt
-
-    #     fig, axs = plt.subplots(ncols=2, nrows=2, figsize=figsize, squeeze=True)
-    #     axs[0, 0].scatter(distances["similarity"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
-    #     axs[0, 0].scatter(distances["similarity"][src, tgt], distances["time_distance"][src, tgt], c="r")
-    #     axs[0, 0].set_xlabel("cc similarity")
-    #     axs[0, 0].set_ylabel("presence ratio")
-
-    #     axs[1, 0].scatter(distances["similarity"].flatten(), distances["cross_cont"].flatten(), c="k", alpha=0.25)
-    #     axs[1, 0].scatter(distances["similarity"][src, tgt], distances["cross_cont"][src, tgt], c="r")
-    #     axs[1, 0].set_xlabel("cc similarity")
-    #     axs[1, 0].set_ylabel("cross cont")
-
-    #     axs[0, 1].scatter(distances["cross_cont"].flatten(), distances["time_distance"].flatten(), c="k", alpha=0.25)
-    #     axs[0, 1].scatter(distances["cross_cont"][src, tgt], distances["time_distance"][src, tgt], c="r")
-    #     axs[0, 1].set_xlabel("cross_cont")
-    #     axs[0, 1].set_ylabel("presence ratio")
-
-    #     plt.show()
+        if min_snr is not None:
+            select_from = analyzer.sorting.unit_ids
+            if analyzer.get_extension("noise_levels") is None:
+                analyzer.compute("noise_levels")
+            if analyzer.get_extension("quality_metrics") is None:
+                analyzer.compute("quality_metrics", metric_names=["snr"])
+
+            snr = analyzer.get_extension("quality_metrics").get_data()["snr"].values
+            select_from = select_from[snr > min_snr]
+            mylist_selection = []
+            for i in mylist:
+                if (i[0] in select_from) or (i[1] in select_from):
+                    mylist_selection += [i]
+            mylist = mylist_selection
+            
+        from spikeinterface.widgets import plot_potential_merges
+        plot_potential_merges(analyzer, mylist , backend='ipywidgets')
\ No newline at end of file

From 76cb82d24d7aed134536b36a45a2406d98e7a45c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 10 Jun 2024 07:36:59 +0000
Subject: [PATCH 062/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sortingcomponents/benchmark/benchmark_merging.py      | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 830a086289..d113e5ef4d 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -106,6 +106,7 @@ def plot_agreements(self, case_keys=None, figsize=(15, 15)):
 
     def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
         from spikeinterface.widgets.widget_list import plot_study_unit_counts
+
         plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
 
     def get_splitted_pairs(self, case_key):
@@ -130,7 +131,7 @@ def plot_splitted_templates(self, case_key, pair_index=0):
         if analyzer.get_extension("spike_amplitudes") is None:
             analyzer.compute(["spike_amplitudes"])
         plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
-    
+
     def plot_potential_merges(self, case_key, min_snr=None):
         analyzer = self.get_sorting_analyzer(case_key)
         mylist = self.get_splitted_pairs(case_key)
@@ -154,6 +155,7 @@ def plot_potential_merges(self, case_key, min_snr=None):
                 if (i[0] in select_from) or (i[1] in select_from):
                     mylist_selection += [i]
             mylist = mylist_selection
-            
+
         from spikeinterface.widgets import plot_potential_merges
-        plot_potential_merges(analyzer, mylist , backend='ipywidgets')
\ No newline at end of file
+
+        plot_potential_merges(analyzer, mylist, backend="ipywidgets")

From 5f4fd0ef8f31bf9a17bc544ed122e81315f9ff98 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 10 Jun 2024 09:50:07 +0200
Subject: [PATCH 063/164] WIP

---
 .../sortingcomponents/benchmark/benchmark_merging.py         | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 830a086289..97c6c2daea 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -111,6 +111,11 @@ def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
     def get_splitted_pairs(self, case_key):
         return self.benchmarks[case_key].splitted_cells
 
+    def get_splitted_pairs_index(self, case_key, pair):
+        for count, i in enumerate(self.benchmarks[case_key].splitted_cells):
+            if i == pair:
+                return count
+
     def plot_splitted_amplitudes(self, case_key, pair_index=0):
         analyzer = self.get_sorting_analyzer(case_key)
         if analyzer.get_extension("spike_amplitudes") is None:

From 4643334b43d67dbeb0b6c42aa9528cb3f110ea16 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 10 Jun 2024 13:27:18 +0200
Subject: [PATCH 064/164] WIP

---
 .../curation/merge_temporal_splits.py         | 27 ++++++++++++++++---
 .../benchmark/benchmark_merging.py            | 14 +++++-----
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 45f38421cd..08ad8e27d1 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 import numpy as np
-
+from ..core.template_tools import get_template_extremum_channel
 from .auto_merge import check_improve_contaminations_score, compute_templates_diff, compute_refrac_period_violations
 
 
@@ -112,6 +112,8 @@ def get_potential_temporal_splits(
     extra_outputs=False,
     steps=None,
     template_metric="l1",
+    maximum_distance_um=50.0,
+    peak_sign='neg',
     **presence_distance_kwargs,
 ):
     """
@@ -150,6 +152,7 @@ def get_potential_temporal_splits(
         steps = [
             "min_spikes",
             "remove_contaminated",
+            "unit_positions",
             "template_similarity",
             "presence_distance",
             "check_increase_score",
@@ -176,7 +179,23 @@ def get_potential_temporal_splits(
         pair_mask[to_remove, :] = False
         pair_mask[:, to_remove] = False
 
-    # STEP 2 : check if potential merge with CC also have template similarity
+    # STEP 3 : unit positions are estimated roughly with channel
+    if "unit_positions" in steps:
+        positions_ext = sorting_analyzer.get_extension("unit_locations")
+        if positions_ext is not None:
+            unit_locations = positions_ext.get_data()[:, :2]
+        else:
+            chan_loc = sorting_analyzer.get_channel_locations()
+            unit_max_chan = get_template_extremum_channel(
+                sorting_analyzer, peak_sign=peak_sign, mode="extremum", outputs="index"
+            )
+            unit_max_chan = list(unit_max_chan.values())
+            unit_locations = chan_loc[unit_max_chan, :]
+
+        unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
+        pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
+
+    # STEP 4 : check if potential merge with CC also have template similarity
     if "template_similarity" in steps:
         templates_ext = sorting_analyzer.get_extension("templates")
         assert (
@@ -202,12 +221,12 @@ def get_potential_temporal_splits(
 
             pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
-    # STEP 3 : validate the potential merges with CC increase the contamination quality metrics
+    # STEP 5 : validate the potential merges with CC increase the contamination quality metrics
     if "presence_distance" in steps:
         presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
         pair_mask = pair_mask & (presence_distances < presence_distance_threshold)
 
-    # STEP 4 : validate the potential merges with CC increase the contamination quality metrics
+    # STEP 6 : validate the potential merges with CC increase the contamination quality metrics
     if "check_increase_score" in steps:
         pair_mask, pairs_decreased_score = check_improve_contaminations_score(
             sorting_analyzer,
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 922bb63c5b..e6a5daee1b 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -117,13 +117,13 @@ def get_splitted_pairs_index(self, case_key, pair):
             if i == pair:
                 return count
 
-    def plot_splitted_amplitudes(self, case_key, pair_index=0):
+    def plot_splitted_amplitudes(self, case_key, pair_index=0, backend="ipywidgets"):
         analyzer = self.get_sorting_analyzer(case_key)
         if analyzer.get_extension("spike_amplitudes") is None:
             analyzer.compute(["spike_amplitudes"])
-        plot_amplitudes(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
+        plot_amplitudes(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index], backend=backend)
 
-    def plot_splitted_correlograms(self, case_key, pair_index=0):
+    def plot_splitted_correlograms(self, case_key, pair_index=0, backend="ipywidgets"):
         analyzer = self.get_sorting_analyzer(case_key)
         if analyzer.get_extension("correlograms") is None:
             analyzer.compute(["correlograms"])
@@ -131,13 +131,13 @@ def plot_splitted_correlograms(self, case_key, pair_index=0):
             analyzer.compute(["template_similarity"])
         plot_crosscorrelograms(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
 
-    def plot_splitted_templates(self, case_key, pair_index=0):
+    def plot_splitted_templates(self, case_key, pair_index=0, backend="ipywidgets"):
         analyzer = self.get_sorting_analyzer(case_key)
         if analyzer.get_extension("spike_amplitudes") is None:
             analyzer.compute(["spike_amplitudes"])
-        plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index])
+        plot_unit_templates(analyzer, unit_ids=self.get_splitted_pairs(case_key)[pair_index], backend=backend)
 
-    def plot_potential_merges(self, case_key, min_snr=None):
+    def plot_potential_merges(self, case_key, min_snr=None, backend="ipywidgets"):
         analyzer = self.get_sorting_analyzer(case_key)
         mylist = self.get_splitted_pairs(case_key)
 
@@ -163,4 +163,4 @@ def plot_potential_merges(self, case_key, min_snr=None):
 
         from spikeinterface.widgets import plot_potential_merges
 
-        plot_potential_merges(analyzer, mylist, backend="ipywidgets")
+        plot_potential_merges(analyzer, mylist, backend=backend)

From 5d0277ebf170a2ff25d369eb2071a32b8532af0c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 10 Jun 2024 11:28:52 +0000
Subject: [PATCH 065/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/merge_temporal_splits.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 08ad8e27d1..f26a24ae2f 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -113,7 +113,7 @@ def get_potential_temporal_splits(
     steps=None,
     template_metric="l1",
     maximum_distance_um=50.0,
-    peak_sign='neg',
+    peak_sign="neg",
     **presence_distance_kwargs,
 ):
     """

From fb6d1ba1eb83c99b0e66db9f8b260f3a2a241667 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 10 Jun 2024 17:19:05 +0200
Subject: [PATCH 066/164] WIP

---
 Untitled.ipynb                                | 218 ++++++++++++++++++
 .../curation/merge_temporal_splits.py         |   2 +-
 2 files changed, 219 insertions(+), 1 deletion(-)
 create mode 100644 Untitled.ipynb

diff --git a/Untitled.ipynb b/Untitled.ipynb
new file mode 100644
index 0000000000..ea2096f3ef
--- /dev/null
+++ b/Untitled.ipynb
@@ -0,0 +1,218 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5e1b6eef-89ab-4e4f-a67f-8e310479b663",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "import spikeinterface.full as si"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f64332b1-160d-453a-b423-029b7159a39f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/pierre/github/spikeinterface/src/spikeinterface/core/generate.py:1947: UserWarning: generate_unit_locations(): no solution for minimum_distance=20 and max_iteration=100\n",
+      "  warnings.warn(f\"generate_unit_locations(): no solution for {minimum_distance=} and {max_iteration=}\")\n",
+      "/home/pierre/github/spikeinterface/src/spikeinterface/core/job_tools.py:103: UserWarning: `n_jobs` is not set so parallel processing is disabled! To speed up computations, it is recommended to set n_jobs either globally (with the `spikeinterface.set_global_job_kwargs()` function) or locally (with the `n_jobs` argument). Use `spikeinterface.set_global_job_kwargs?` for more information about job_kwargs.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "87d158a7f47541cfaa056744533134ae",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "estimate_sparsity:   0%|          | 0/10 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rec, sorting = si.generate_ground_truth_recording(num_channels=128, num_units=250)\n",
+    "sa = si.create_sorting_analyzer(sorting, rec)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d587d6cc-8924-419f-a916-f1fb2f924cbf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9a2f38e9ec544e479fb925643e7fa374",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "estimate_templates_with_accumulator:   0%|          | 0/10 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "si.set_global_job_kwargs(n_jobs=0.8)\n",
+    "sa.compute(['random_spikes', 'templates'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4139775f-4b73-45c1-ba61-fbcf5b88248d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "res = {}\n",
+    "for method in ['union', 'intersection', 'dense']:\n",
+    "    print(method)\n",
+    "    res[method] = sa.compute('template_similarity', support=method, method='l1').get_data()\n",
+    "import pylab as plt\n",
+    "fig, axes = plt.subplots(2, len(res.keys()), figsize=(15, 5))\n",
+    "for count, key in enumerate(res.keys()):\n",
+    "    axes[0, count].imshow(res[key])\n",
+    "    axes[0, count].set_title(key)\n",
+    "    axes[1, count].hist(res[key].flatten(), 100)\n",
+    "    axes[1, count].set_yscale('log')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "57e30e39-de70-4b9e-858b-11f46919c87b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "union\n",
+      "intersection\n",
+      "dense\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "res = {}\n",
+    "for method in ['union', 'intersection', 'dense']:\n",
+    "    print(method)\n",
+    "    res[method] = sa.compute('template_similarity', support=method, method='l2').get_data()\n",
+    "import pylab as plt\n",
+    "fig, axes = plt.subplots(2, len(res.keys()), figsize=(15, 5))\n",
+    "for count, key in enumerate(res.keys()):\n",
+    "    axes[0, count].imshow(res[key])\n",
+    "    axes[0, count].set_title(key)\n",
+    "    axes[1, count].hist(res[key].flatten(), 100)\n",
+    "    axes[1, count].set_yscale('log')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "09205f26-0aaf-4808-a138-c723f22180f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "union\n",
+      "intersection\n",
+      "dense\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "res = {}\n",
+    "for method in ['union', 'intersection', 'dense']:\n",
+    "    print(method)\n",
+    "    res[method] = sa.compute('template_similarity', support=method, method='cosine').get_data()\n",
+    "import pylab as plt\n",
+    "fig, axes = plt.subplots(2, len(res.keys()), figsize=(15, 5))\n",
+    "for count, key in enumerate(res.keys()):\n",
+    "    axes[0, count].imshow(res[key])\n",
+    "    axes[0, count].set_title(key)\n",
+    "    axes[1, count].hist(res[key].flatten(), 100)\n",
+    "    axes[1, count].set_yscale('log')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dfbb6506-ba5f-438a-a0c9-49957b4b58bf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index f26a24ae2f..e3f3d83a64 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -112,7 +112,7 @@ def get_potential_temporal_splits(
     extra_outputs=False,
     steps=None,
     template_metric="l1",
-    maximum_distance_um=50.0,
+    maximum_distance_um=150.0,
     peak_sign="neg",
     **presence_distance_kwargs,
 ):

From a48ac2e58dd3decf0ad7f5d222b80aa8b99bfbea Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 12 Jun 2024 11:18:42 +0200
Subject: [PATCH 067/164] Lussac merging can use new metrics

---
 .../sortingcomponents/merging/lussac.py       | 97 +++++++++++--------
 1 file changed, 57 insertions(+), 40 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 4322de114f..fc6fb7e7a4 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -232,12 +232,13 @@ def estimate_cross_contamination(
 def lussac_merge(
     analyzer,
     refractory_period,
-    minimum_spikes=100,
+    minimum_spikes= 50,
     template_diff_thresh: float = 0.25,
     CC_threshold: float = 0.2,
     max_shift: int = 5,
     num_channels: int = 5,
     template_metric="l1",
+    p_value: float = 0.2,
 ) -> list[tuple]:
     """
     Looks at a sorting analyzer, and returns a list of potential pairwise merges.
@@ -260,17 +261,23 @@ def lussac_merge(
         The maximum shift when comparing the templates (in number of time samples).
     max_channels : int
         The maximum number of channels to consider when comparing the templates.
+    p_value : float, default: 0.2
+        The minimal p_value to be considered for putative merges
     """
 
     assert HAVE_NUMBA, "Numba should be installed"
-    pairs = []
     sorting = analyzer.sorting
+    pairs = []
     sf = analyzer.recording.sampling_frequency
     n_frames = analyzer.recording.get_num_samples()
     sparsity = analyzer.sparsity
     all_shifts = range(-max_shift, max_shift + 1)
     unit_ids = sorting.unit_ids
 
+    template_similarities = analyzer.get_extension('template_similarity')
+    if template_similarities is not None:
+        template_diff_thresh = 1 - template_diff_thresh
+
     if sparsity is None:
         adaptative_masks = False
         sparsity_mask = None
@@ -279,66 +286,75 @@ def lussac_merge(
         sparsity_mask = sparsity.mask
 
     for unit_ind1 in range(len(unit_ids)):
+        
+        unit_id1 = unit_ids[unit_ind1]
+        spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
+        if not len(spike_train1) > minimum_spikes:
+            continue
+        template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
+
         for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
 
-            unit_id1 = unit_ids[unit_ind1]
             unit_id2 = unit_ids[unit_ind2]
 
             # Checking that we have enough spikes
-            spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
-            if not (len(spike_train1) > minimum_spikes and len(spike_train2) > minimum_spikes):
+            if not len(spike_train2) > minimum_spikes:
                 continue
 
             # Computing template difference
-            template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
             template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
 
-            if not adaptative_masks:
-                chan_inds = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:num_channels]
+            if template_similarities is not None:
+                max_diff = template_similarities.get_data()[unit_ind1, unit_ind2]
             else:
-                chan_inds = np.flatnonzero(sparsity_mask[unit_ind1] * sparsity_mask[unit_ind2])
-
-            if len(chan_inds) > 0:
-                template1 = template1[:, chan_inds]
-                template2 = template2[:, chan_inds]
-
-                if template_metric == "l1":
-                    norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
-                elif template_metric == "l2":
-                    norm = np.sum(template1**2) + np.sum(template2**2)
-                elif template_metric == "cosine":
-                    norm = np.linalg.norm(template1) * np.linalg.norm(template2)
-
-                all_shift_diff = []
-                n = len(template1)
-                for shift in all_shifts:
-                    temp1 = template1[max_shift : n - max_shift, :]
-                    temp2 = template2[max_shift + shift : n - max_shift + shift, :]
+
+                if not adaptative_masks:
+                    chan_inds = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:num_channels]
+                else:
+                    chan_inds = np.flatnonzero(sparsity_mask[unit_ind1] * sparsity_mask[unit_ind2])
+
+                if len(chan_inds) > 0:
+                    template1 = template1[:, chan_inds]
+                    template2 = template2[:, chan_inds]
+
                     if template_metric == "l1":
-                        d = np.sum(np.abs(temp1 - temp2)) / norm
+                        norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
                     elif template_metric == "l2":
-                        d = np.linalg.norm(temp1 - temp2) / norm
+                        norm = np.sum(template1**2) + np.sum(template2**2)
                     elif template_metric == "cosine":
-                        d = 1 - np.sum(temp1 * temp2) / norm
-                    all_shift_diff.append(d)
-            else:
-                all_shift_diff = [1] * len(all_shifts)
+                        norm = np.linalg.norm(template1) * np.linalg.norm(template2)
+
+                    all_shift_diff = []
+                    n = len(template1)
+                    for shift in all_shifts:
+                        temp1 = template1[max_shift : n - max_shift, :]
+                        temp2 = template2[max_shift + shift : n - max_shift + shift, :]
+                        if template_metric == "l1":
+                            d = np.sum(np.abs(temp1 - temp2)) / norm
+                        elif template_metric == "l2":
+                            d = np.linalg.norm(temp1 - temp2) / norm
+                        elif template_metric == "cosine":
+                            d = 1 - np.sum(temp1 * temp2) / norm
+                        all_shift_diff.append(d)
+                else:
+                    all_shift_diff = [1] * len(all_shifts)
 
-            max_diff = np.min(all_shift_diff)
+                max_diff = np.min(all_shift_diff)
 
             if max_diff > template_diff_thresh:
                 continue
 
             # Compuyting the cross-contamination difference
-            CC, p_value = estimate_cross_contamination(
+            CC, p = estimate_cross_contamination(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
-            if p_value < 0.2:
-                continue
 
+            if (p < p_value):
+                continue
+            
             pairs.append((unit_id1, unit_id2))
-
+    
     return pairs
 
 
@@ -351,9 +367,8 @@ class LussacMerging(BaseMergingEngine):
         "templates": None,
         "minimum_spikes": 50,
         "refractory_period": (0.3, 1.0),
-        "template_metric": "l1",
-        "num_channels": 5,
-        "verbose": False,
+        "template_diff_thresh" : 0.3,
+        "verbose": True,
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -376,6 +391,8 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
+        self.analyzer.compute("template_similarity")
+
     def run(self, extra_outputs=False):
         merges = lussac_merge(self.analyzer, **self.params)
         if self.verbose:

From f560406e08a37b1a94b8db0edd109eb4e436539a Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 12 Jun 2024 09:20:03 +0000
Subject: [PATCH 068/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sortingcomponents/merging/lussac.py            | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index fc6fb7e7a4..b35ecb6994 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -232,7 +232,7 @@ def estimate_cross_contamination(
 def lussac_merge(
     analyzer,
     refractory_period,
-    minimum_spikes= 50,
+    minimum_spikes=50,
     template_diff_thresh: float = 0.25,
     CC_threshold: float = 0.2,
     max_shift: int = 5,
@@ -274,7 +274,7 @@ def lussac_merge(
     all_shifts = range(-max_shift, max_shift + 1)
     unit_ids = sorting.unit_ids
 
-    template_similarities = analyzer.get_extension('template_similarity')
+    template_similarities = analyzer.get_extension("template_similarity")
     if template_similarities is not None:
         template_diff_thresh = 1 - template_diff_thresh
 
@@ -286,7 +286,7 @@ def lussac_merge(
         sparsity_mask = sparsity.mask
 
     for unit_ind1 in range(len(unit_ids)):
-        
+
         unit_id1 = unit_ids[unit_ind1]
         spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
         if not len(spike_train1) > minimum_spikes:
@@ -350,11 +350,11 @@ def lussac_merge(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
 
-            if (p < p_value):
+            if p < p_value:
                 continue
-            
+
             pairs.append((unit_id1, unit_id2))
-    
+
     return pairs
 
 
@@ -367,7 +367,7 @@ class LussacMerging(BaseMergingEngine):
         "templates": None,
         "minimum_spikes": 50,
         "refractory_period": (0.3, 1.0),
-        "template_diff_thresh" : 0.3,
+        "template_diff_thresh": 0.3,
         "verbose": True,
     }
 

From 8aca00912d24ffb64a3bae7a3a1e6f10cc5af814 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 12 Jun 2024 20:45:17 +0200
Subject: [PATCH 069/164] WIP

---
 src/spikeinterface/curation/auto_merge.py     |  5 +--
 .../curation/merge_temporal_splits.py         | 31 ++++++++++---------
 .../sortingcomponents/merging/lussac.py       | 20 ++++++------
 3 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index c754fc17d8..151984300c 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -209,7 +209,7 @@ def get_potential_auto_merge(
         template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
         if template_similarity_ext is not None:
             templates_similarity = template_similarity_ext.get_data()
-            pair_mask = pair_mask & (templates_similarity > (1 - template_diff_thresh))
+            templates_diff = 1 - templates_similarity
 
         else:
             templates_array = templates_ext.get_data(outputs="numpy")
@@ -224,7 +224,7 @@ def get_potential_auto_merge(
                 sparsity=sorting_analyzer.sparsity,
             )
 
-            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
     # STEP 6 : validate the potential merges with CC increase the contamination quality metrics
     if "check_increase_score" in steps:
@@ -248,6 +248,7 @@ def get_potential_auto_merge(
             correlograms_smoothed=correlograms_smoothed,
             correlogram_diff=correlogram_diff,
             win_sizes=win_sizes,
+            unit_distances=unit_distances,
             templates_diff=templates_diff,
             pairs_decreased_score=pairs_decreased_score,
         )
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index e3f3d83a64..14fce23e53 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -40,18 +40,21 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=9
 
     h1, _ = np.histogram(st1, bins)
     h1 = h1.astype(float)
-    norm_value1 = np.percentile(h1, percentile_norm)
+    #norm_value1 = np.linalg.norm(h1)
 
     h2, _ = np.histogram(st2, bins)
     h2 = h2.astype(float)
-    norm_value2 = np.percentile(h2, percentile_norm)
-
-    if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
-        h1 = h1 / norm_value1
-        h2 = h2 / norm_value2
-        d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / sorting.get_total_duration()
-    else:
-        d = 1.0
+    #norm_value2 = np.linalg.norm(h2)#np.percentile(h2, percentile_norm)
+
+    # if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
+    #     h1 = h1 / norm_value1
+    #     h2 = h2 / norm_value2
+    #     d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / sorting.get_total_duration()
+    # else:
+    #     d = 1.0
+    import scipy
+    xaxis = bins[1:]/sorting.sampling_frequency
+    d = scipy.stats.wasserstein_distance(xaxis, xaxis, h1, h2)
 
     return d
 
@@ -101,7 +104,7 @@ def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
 def get_potential_temporal_splits(
     sorting_analyzer,
     minimum_spikes=100,
-    presence_distance_threshold=0.1,
+    presence_distance_threshold=50,
     template_diff_thresh=0.25,
     censored_period_ms=0.3,
     refractory_period_ms=1.0,
@@ -205,7 +208,7 @@ def get_potential_temporal_splits(
         template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
         if template_similarity_ext is not None:
             templates_similarity = template_similarity_ext.get_data()
-            pair_mask = pair_mask & (templates_similarity > (1 - template_diff_thresh))
+            templates_diff = 1 - templates_similarity
         else:
             templates_array = templates_ext.get_data(outputs="numpy")
 
@@ -219,13 +222,12 @@ def get_potential_temporal_splits(
                 sparsity=sorting_analyzer.sparsity,
             )
 
-            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
     # STEP 5 : validate the potential merges with CC increase the contamination quality metrics
     if "presence_distance" in steps:
         presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
-        pair_mask = pair_mask & (presence_distances < presence_distance_threshold)
-
+        pair_mask = pair_mask & (presence_distances > presence_distance_threshold)
     # STEP 6 : validate the potential merges with CC increase the contamination quality metrics
     if "check_increase_score" in steps:
         pair_mask, pairs_decreased_score = check_improve_contaminations_score(
@@ -244,6 +246,7 @@ def get_potential_temporal_splits(
     if extra_outputs:
         outs = dict(
             templates_diff=templates_diff,
+            unit_distances=unit_distances,
             presence_distances=presence_distances,
             pairs_decreased_score=pairs_decreased_score,
         )
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index b35ecb6994..92983d0972 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -232,7 +232,7 @@ def estimate_cross_contamination(
 def lussac_merge(
     analyzer,
     refractory_period,
-    minimum_spikes=50,
+    minimum_spikes= 50,
     template_diff_thresh: float = 0.25,
     CC_threshold: float = 0.2,
     max_shift: int = 5,
@@ -267,14 +267,14 @@ def lussac_merge(
 
     assert HAVE_NUMBA, "Numba should be installed"
     sorting = analyzer.sorting
-    pairs = []
+    potential_merges = []
     sf = analyzer.recording.sampling_frequency
     n_frames = analyzer.recording.get_num_samples()
     sparsity = analyzer.sparsity
     all_shifts = range(-max_shift, max_shift + 1)
     unit_ids = sorting.unit_ids
 
-    template_similarities = analyzer.get_extension("template_similarity")
+    template_similarities = analyzer.get_extension('template_similarity')
     if template_similarities is not None:
         template_diff_thresh = 1 - template_diff_thresh
 
@@ -286,7 +286,7 @@ def lussac_merge(
         sparsity_mask = sparsity.mask
 
     for unit_ind1 in range(len(unit_ids)):
-
+        
         unit_id1 = unit_ids[unit_ind1]
         spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
         if not len(spike_train1) > minimum_spikes:
@@ -350,12 +350,12 @@ def lussac_merge(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
 
-            if p < p_value:
+            if (p < p_value):
                 continue
-
-            pairs.append((unit_id1, unit_id2))
-
-    return pairs
+            
+            potential_merges.append((unit_id1, unit_id2))
+    
+    return potential_merges
 
 
 class LussacMerging(BaseMergingEngine):
@@ -367,7 +367,7 @@ class LussacMerging(BaseMergingEngine):
         "templates": None,
         "minimum_spikes": 50,
         "refractory_period": (0.3, 1.0),
-        "template_diff_thresh": 0.3,
+        "template_diff_thresh" : 0.3,
         "verbose": True,
     }
 

From 2c07c6eea6ab52a0c2759d742563ddb8a5b9cab1 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 12 Jun 2024 18:45:46 +0000
Subject: [PATCH 070/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../curation/merge_temporal_splits.py              |  7 ++++---
 .../sortingcomponents/merging/lussac.py            | 14 +++++++-------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 14fce23e53..920ee33429 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -40,11 +40,11 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=9
 
     h1, _ = np.histogram(st1, bins)
     h1 = h1.astype(float)
-    #norm_value1 = np.linalg.norm(h1)
+    # norm_value1 = np.linalg.norm(h1)
 
     h2, _ = np.histogram(st2, bins)
     h2 = h2.astype(float)
-    #norm_value2 = np.linalg.norm(h2)#np.percentile(h2, percentile_norm)
+    # norm_value2 = np.linalg.norm(h2)#np.percentile(h2, percentile_norm)
 
     # if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
     #     h1 = h1 / norm_value1
@@ -53,7 +53,8 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=9
     # else:
     #     d = 1.0
     import scipy
-    xaxis = bins[1:]/sorting.sampling_frequency
+
+    xaxis = bins[1:] / sorting.sampling_frequency
     d = scipy.stats.wasserstein_distance(xaxis, xaxis, h1, h2)
 
     return d
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 92983d0972..ddcc800aec 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -232,7 +232,7 @@ def estimate_cross_contamination(
 def lussac_merge(
     analyzer,
     refractory_period,
-    minimum_spikes= 50,
+    minimum_spikes=50,
     template_diff_thresh: float = 0.25,
     CC_threshold: float = 0.2,
     max_shift: int = 5,
@@ -274,7 +274,7 @@ def lussac_merge(
     all_shifts = range(-max_shift, max_shift + 1)
     unit_ids = sorting.unit_ids
 
-    template_similarities = analyzer.get_extension('template_similarity')
+    template_similarities = analyzer.get_extension("template_similarity")
     if template_similarities is not None:
         template_diff_thresh = 1 - template_diff_thresh
 
@@ -286,7 +286,7 @@ def lussac_merge(
         sparsity_mask = sparsity.mask
 
     for unit_ind1 in range(len(unit_ids)):
-        
+
         unit_id1 = unit_ids[unit_ind1]
         spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
         if not len(spike_train1) > minimum_spikes:
@@ -350,11 +350,11 @@ def lussac_merge(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
 
-            if (p < p_value):
+            if p < p_value:
                 continue
-            
+
             potential_merges.append((unit_id1, unit_id2))
-    
+
     return potential_merges
 
 
@@ -367,7 +367,7 @@ class LussacMerging(BaseMergingEngine):
         "templates": None,
         "minimum_spikes": 50,
         "refractory_period": (0.3, 1.0),
-        "template_diff_thresh" : 0.3,
+        "template_diff_thresh": 0.3,
         "verbose": True,
     }
 

From 65b01beb9d370587c5f4357e748f87208cd23ac3 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 13:00:45 +0200
Subject: [PATCH 071/164] Merging curation functions

---
 src/spikeinterface/curation/auto_merge.py     |  92 +++++++---
 .../curation/merge_temporal_splits.py         | 171 +-----------------
 2 files changed, 67 insertions(+), 196 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 151984300c..816ad1255d 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -9,6 +9,7 @@
 from ..qualitymetrics import compute_refrac_period_violations, compute_firing_rates
 
 from .mergeunitssorting import MergeUnitsSorting
+from .merge_temporal_splits import compute_presence_distance
 
 
 def get_potential_auto_merge(
@@ -28,10 +29,13 @@ def get_potential_auto_merge(
     censor_correlograms_ms: float = 0.15,
     num_channels=5,
     num_shift=5,
-    firing_contamination_balance=1.5,
+    firing_contamination_balance=2.5,
     extra_outputs=False,
     steps=None,
+    presence_distance_thresh=100,
+    preset=None,
     template_metric="l1",
+    **presence_distance_kwargs
 ):
     """
     Algorithm to find and check potential merges between units.
@@ -47,7 +51,8 @@ def get_potential_auto_merge(
         * STEP 3: estimated unit locations are close enough (`maximum_distance_um`)
         * STEP 4: the cross-correlograms of the two units are similar to each auto-corrleogram (`corr_diff_thresh`)
         * STEP 5: the templates of the two units are similar (`template_diff_thresh`)
-        * STEP 6: the unit "quality score" is increased after the merge.
+        * STEP 6: [optional] the presence distance of two units
+        * STEP 7: the unit "quality score" is increased after the merge.
 
     The "quality score" factors in the increase in firing rate (**f**) due to the merge and a possible increase in
     contamination (**C**), wheighted by a factor **k** (`firing_contamination_balance`).
@@ -96,15 +101,18 @@ def get_potential_auto_merge(
         Number of channel to use for template similarity computation
     num_shift : int, default: 5
         Number of shifts in samles to be explored for template similarity computation
-    firing_contamination_balance : float, default: 1.5
+    firing_contamination_balance : float, default: 2.5
         Parameter to control the balance between firing rate and contamination in computing unit "quality score"
+    presence_distance_thresh: float, default: 100
+        Parameter to control how present two units should be simultaneously
     extra_outputs : bool, default: False
         If True, an additional dictionary (`outs`) with processed data is returned
     steps : None or list of str, default: None
         which steps to run (gives flexibility to running just some steps)
         If None all steps are done.
-        Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram", "template_similarity",
-        "check_increase_score". Please check steps explanations above!
+        Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram", 
+        "template_similarity", "presence_distance", "check_increase_score". 
+        Please check steps explanations above!
     template_metric : 'l1', 'l2' or 'cosine'
         The metric to consider when measuring the distances between templates. Default is l1
 
@@ -122,6 +130,7 @@ def get_potential_auto_merge(
     sorting = sorting_analyzer.sorting
     recording = sorting_analyzer.recording
     unit_ids = sorting.unit_ids
+    sorting.register_recording(recording)
 
     # to get fast computation we will not analyse pairs when:
     #    * not enough spikes for one of theses
@@ -129,18 +138,32 @@ def get_potential_auto_merge(
     #    * to far away one from each other
 
     if steps is None:
-        steps = [
-            "min_spikes",
-            "remove_contaminated",
-            "unit_positions",
-            "correlogram",
-            "template_similarity",
-            "check_increase_score",
-        ]
+        if preset is None:
+            steps = [
+                "min_spikes",
+                "remove_contaminated",
+                "unit_positions",
+                "correlogram",
+                "template_similarity",
+                "check_increase_score",
+            ]
+        elif preset == 'temporal_splits':
+            steps = [
+                "min_spikes",
+                "remove_contaminated",
+                "unit_positions",
+                "correlogram",
+                "template_similarity",
+                "presence_distance",
+                "check_increase_score",
+            ]
 
     n = unit_ids.size
     pair_mask = np.ones((n, n), dtype="bool")
 
+    if extra_outputs:
+        outs = dict()
+
     # STEP 1 :
     if "min_spikes" in steps:
         num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
@@ -175,6 +198,9 @@ def get_potential_auto_merge(
         unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
         pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
 
+        if extra_outputs:
+            outs['unit_distances']=unit_distances
+
     # STEP 4 : potential auto merge by correlogram
     if "correlogram" in steps:
         correlograms, bins = compute_correlograms(sorting, window_ms=window_ms, bin_ms=bin_ms, method="numba")
@@ -198,6 +224,12 @@ def get_potential_auto_merge(
         )
         # print(correlogram_diff)
         pair_mask = pair_mask & (correlogram_diff < corr_diff_thresh)
+        if extra_outputs:
+            outs['correlograms']=correlograms
+            outs['bins']=bins
+            outs['correlograms_smoothed']=correlograms_smoothed
+            outs['correlogram_diff']=correlogram_diff
+            outs['win_sizes']=win_sizes
 
     # STEP 5 : check if potential merge with CC also have template similarity
     if "template_similarity" in steps:
@@ -226,7 +258,19 @@ def get_potential_auto_merge(
 
         pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
-    # STEP 6 : validate the potential merges with CC increase the contamination quality metrics
+        if extra_outputs:
+            outs['templates_diff']=templates_diff
+
+
+    # STEP 6 : [optional] check how the rates overlap in times
+    if "presence_distance" in steps:
+        presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
+        pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
+
+        if extra_outputs:
+            outs['presence_distances']=presence_distances
+
+    # STEP 7 : validate the potential merges with CC increase the contamination quality metrics
     if "check_increase_score" in steps:
         pair_mask, pairs_decreased_score = check_improve_contaminations_score(
             sorting_analyzer,
@@ -236,22 +280,14 @@ def get_potential_auto_merge(
             refractory_period_ms,
             censored_period_ms,
         )
+        if extra_outputs:
+            outs['pairs_decreased_score']=pairs_decreased_score
 
     # FINAL STEP : create the final list from pair_mask boolean matrix
     ind1, ind2 = np.nonzero(pair_mask)
     potential_merges = list(zip(unit_ids[ind1], unit_ids[ind2]))
 
     if extra_outputs:
-        outs = dict(
-            correlograms=correlograms,
-            bins=bins,
-            correlograms_smoothed=correlograms_smoothed,
-            correlogram_diff=correlogram_diff,
-            win_sizes=win_sizes,
-            unit_distances=unit_distances,
-            templates_diff=templates_diff,
-            pairs_decreased_score=pairs_decreased_score,
-        )
         return potential_merges, outs
     else:
         return potential_merges
@@ -538,10 +574,10 @@ def check_improve_contaminations_score(
         f_new = compute_firing_rates(sorting_analyzer_new)[unit_id1]
 
         # old and new scores
-        k = 1 + firing_contamination_balance
-        score_1 = f_1 * (1 - k * c_1)
-        score_2 = f_2 * (1 - k * c_2)
-        score_new = f_new * (1 - k * c_new)
+        k = firing_contamination_balance
+        score_1 = f_1 * (1 - (k + 1) * c_1)
+        score_2 = f_2 * (1 - (k + 1) * c_2)
+        score_new = f_new * (1 - (k + 1) * c_new)
 
         if score_new < score_1 or score_new < score_2:
             # the score is not improved
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 14fce23e53..653bfbb79c 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -1,15 +1,12 @@
 from __future__ import annotations
 import numpy as np
-from ..core.template_tools import get_template_extremum_channel
-from .auto_merge import check_improve_contaminations_score, compute_templates_diff, compute_refrac_period_violations
-
 
 def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
     """
     Compute the presence distance between two units.
 
-    The presence distance is defined as the sum of the absolute difference between the sum of
-    the normalized firing profiles of the two units and a constant firing profile.
+    The presence distance is defined as the Wasserstein distance between the two histograms of
+    the firing activity over time.
 
     Parameters
     ----------
@@ -40,18 +37,10 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=9
 
     h1, _ = np.histogram(st1, bins)
     h1 = h1.astype(float)
-    #norm_value1 = np.linalg.norm(h1)
 
     h2, _ = np.histogram(st2, bins)
     h2 = h2.astype(float)
-    #norm_value2 = np.linalg.norm(h2)#np.percentile(h2, percentile_norm)
-
-    # if not np.isnan(norm_value1) and not np.isnan(norm_value2) and norm_value1 > 0 and norm_value2 > 0:
-    #     h1 = h1 / norm_value1
-    #     h2 = h2 / norm_value2
-    #     d = np.sum(np.abs(h1 + h2 - np.ones_like(h1))) / sorting.get_total_duration()
-    # else:
-    #     d = 1.0
+
     import scipy
     xaxis = bins[1:]/sorting.sampling_frequency
     d = scipy.stats.wasserstein_distance(xaxis, xaxis, h1, h2)
@@ -99,157 +88,3 @@ def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
             presence_distances[unit_ind1, unit_ind2] = d
 
     return presence_distances
-
-
-def get_potential_temporal_splits(
-    sorting_analyzer,
-    minimum_spikes=100,
-    presence_distance_threshold=50,
-    template_diff_thresh=0.25,
-    censored_period_ms=0.3,
-    refractory_period_ms=1.0,
-    num_channels=5,
-    num_shift=5,
-    contamination_threshold=0.2,
-    firing_contamination_balance=1.5,
-    extra_outputs=False,
-    steps=None,
-    template_metric="l1",
-    maximum_distance_um=150.0,
-    peak_sign="neg",
-    **presence_distance_kwargs,
-):
-    """
-    Algorithm to find and check potential temporal merges between units.
-
-    The merges are proposed when the following criteria are met:
-
-        * STEP 1: enough spikes are found in each units for computing the correlogram (`minimum_spikes`)
-        * STEP 2: the templates of the two units are similar (`template_diff_thresh`)
-        * STEP 3: the presence distance of the two units is high
-        * STEP 4: the unit "quality score" is increased after the merge.
-
-    The "quality score" factors in the increase in firing rate (**f**) due to the merge and a possible increase in
-    contamination (**C**), wheighted by a factor **k** (`firing_contamination_balance`).
-
-    .. math::
-
-        Q = f(1 - (k + 1)C)
-
-
-    """
-
-    import scipy
-
-    sorting = sorting_analyzer.sorting
-    recording = sorting_analyzer.recording
-    unit_ids = sorting.unit_ids
-    sorting.register_recording(recording)
-
-    # to get fast computation we will not analyse pairs when:
-    #    * not enough spikes for one of theses
-    #    * auto correlogram is contaminated
-    #    * to far away one from each other
-
-    if steps is None:
-        steps = [
-            "min_spikes",
-            "remove_contaminated",
-            "unit_positions",
-            "template_similarity",
-            "presence_distance",
-            "check_increase_score",
-        ]
-
-    n = unit_ids.size
-    pair_mask = np.ones((n, n), dtype="bool")
-
-    # STEP 1 :
-    if "min_spikes" in steps:
-        num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
-        to_remove = num_spikes < minimum_spikes
-        pair_mask[to_remove, :] = False
-        pair_mask[:, to_remove] = False
-
-    # STEP 2 : remove contaminated auto corr
-    if "remove_contaminated" in steps:
-        contaminations, nb_violations = compute_refrac_period_violations(
-            sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
-        )
-        nb_violations = np.array(list(nb_violations.values()))
-        contaminations = np.array(list(contaminations.values()))
-        to_remove = contaminations > contamination_threshold
-        pair_mask[to_remove, :] = False
-        pair_mask[:, to_remove] = False
-
-    # STEP 3 : unit positions are estimated roughly with channel
-    if "unit_positions" in steps:
-        positions_ext = sorting_analyzer.get_extension("unit_locations")
-        if positions_ext is not None:
-            unit_locations = positions_ext.get_data()[:, :2]
-        else:
-            chan_loc = sorting_analyzer.get_channel_locations()
-            unit_max_chan = get_template_extremum_channel(
-                sorting_analyzer, peak_sign=peak_sign, mode="extremum", outputs="index"
-            )
-            unit_max_chan = list(unit_max_chan.values())
-            unit_locations = chan_loc[unit_max_chan, :]
-
-        unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
-        pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
-
-    # STEP 4 : check if potential merge with CC also have template similarity
-    if "template_similarity" in steps:
-        templates_ext = sorting_analyzer.get_extension("templates")
-        assert (
-            templates_ext is not None
-        ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
-
-        template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
-        if template_similarity_ext is not None:
-            templates_similarity = template_similarity_ext.get_data()
-            templates_diff = 1 - templates_similarity
-        else:
-            templates_array = templates_ext.get_data(outputs="numpy")
-
-            templates_diff = compute_templates_diff(
-                sorting,
-                templates_array,
-                num_channels=num_channels,
-                num_shift=num_shift,
-                pair_mask=pair_mask,
-                template_metric=template_metric,
-                sparsity=sorting_analyzer.sparsity,
-            )
-
-        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
-
-    # STEP 5 : validate the potential merges with CC increase the contamination quality metrics
-    if "presence_distance" in steps:
-        presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
-        pair_mask = pair_mask & (presence_distances > presence_distance_threshold)
-    # STEP 6 : validate the potential merges with CC increase the contamination quality metrics
-    if "check_increase_score" in steps:
-        pair_mask, pairs_decreased_score = check_improve_contaminations_score(
-            sorting_analyzer,
-            pair_mask,
-            contaminations,
-            firing_contamination_balance,
-            refractory_period_ms,
-            censored_period_ms,
-        )
-
-    # FINAL STEP : create the final list from pair_mask boolean matrix
-    ind1, ind2 = np.nonzero(pair_mask)
-    potential_merges = list(zip(unit_ids[ind1], unit_ids[ind2]))
-
-    if extra_outputs:
-        outs = dict(
-            templates_diff=templates_diff,
-            unit_distances=unit_distances,
-            presence_distances=presence_distances,
-            pairs_decreased_score=pairs_decreased_score,
-        )
-        return potential_merges, outs
-    else:
-        return potential_merges

From f7bd29b3183849755a7658e3af12437b485fbd16 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 13 Jun 2024 11:01:35 +0000
Subject: [PATCH 072/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py     | 27 +++++++++----------
 .../curation/merge_temporal_splits.py         |  1 +
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 816ad1255d..e79f572196 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -35,7 +35,7 @@ def get_potential_auto_merge(
     presence_distance_thresh=100,
     preset=None,
     template_metric="l1",
-    **presence_distance_kwargs
+    **presence_distance_kwargs,
 ):
     """
     Algorithm to find and check potential merges between units.
@@ -110,8 +110,8 @@ def get_potential_auto_merge(
     steps : None or list of str, default: None
         which steps to run (gives flexibility to running just some steps)
         If None all steps are done.
-        Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram", 
-        "template_similarity", "presence_distance", "check_increase_score". 
+        Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram",
+        "template_similarity", "presence_distance", "check_increase_score".
         Please check steps explanations above!
     template_metric : 'l1', 'l2' or 'cosine'
         The metric to consider when measuring the distances between templates. Default is l1
@@ -147,7 +147,7 @@ def get_potential_auto_merge(
                 "template_similarity",
                 "check_increase_score",
             ]
-        elif preset == 'temporal_splits':
+        elif preset == "temporal_splits":
             steps = [
                 "min_spikes",
                 "remove_contaminated",
@@ -199,7 +199,7 @@ def get_potential_auto_merge(
         pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
 
         if extra_outputs:
-            outs['unit_distances']=unit_distances
+            outs["unit_distances"] = unit_distances
 
     # STEP 4 : potential auto merge by correlogram
     if "correlogram" in steps:
@@ -225,11 +225,11 @@ def get_potential_auto_merge(
         # print(correlogram_diff)
         pair_mask = pair_mask & (correlogram_diff < corr_diff_thresh)
         if extra_outputs:
-            outs['correlograms']=correlograms
-            outs['bins']=bins
-            outs['correlograms_smoothed']=correlograms_smoothed
-            outs['correlogram_diff']=correlogram_diff
-            outs['win_sizes']=win_sizes
+            outs["correlograms"] = correlograms
+            outs["bins"] = bins
+            outs["correlograms_smoothed"] = correlograms_smoothed
+            outs["correlogram_diff"] = correlogram_diff
+            outs["win_sizes"] = win_sizes
 
     # STEP 5 : check if potential merge with CC also have template similarity
     if "template_similarity" in steps:
@@ -259,8 +259,7 @@ def get_potential_auto_merge(
         pair_mask = pair_mask & (templates_diff < template_diff_thresh)
 
         if extra_outputs:
-            outs['templates_diff']=templates_diff
-
+            outs["templates_diff"] = templates_diff
 
     # STEP 6 : [optional] check how the rates overlap in times
     if "presence_distance" in steps:
@@ -268,7 +267,7 @@ def get_potential_auto_merge(
         pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
 
         if extra_outputs:
-            outs['presence_distances']=presence_distances
+            outs["presence_distances"] = presence_distances
 
     # STEP 7 : validate the potential merges with CC increase the contamination quality metrics
     if "check_increase_score" in steps:
@@ -281,7 +280,7 @@ def get_potential_auto_merge(
             censored_period_ms,
         )
         if extra_outputs:
-            outs['pairs_decreased_score']=pairs_decreased_score
+            outs["pairs_decreased_score"] = pairs_decreased_score
 
     # FINAL STEP : create the final list from pair_mask boolean matrix
     ind1, ind2 = np.nonzero(pair_mask)
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index e7991da73b..e58743f171 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 import numpy as np
 
+
 def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
     """
     Compute the presence distance between two units.

From d777fae3324e884a8a809533ba31154ca74fd8e7 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 13:02:03 +0200
Subject: [PATCH 073/164] WIP

---
 src/spikeinterface/curation/merge_temporal_splits.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index e7991da73b..91dfecf874 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 import numpy as np
 
-def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=90, bins=None):
+def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None):
     """
     Compute the presence distance between two units.
 
@@ -18,8 +18,6 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, percentile_norm=9
         The id of the second unit.
     bin_duration_s: float
         The duration of the bin in seconds.
-    percentile_norm: float
-        The percentile used to normalize the firing rate.
     bins: array-like
         The bins used to compute the firing rate.
 

From 2d8df387922dc9fa9eec6d1a4f81816a999243b2 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 13 Jun 2024 11:02:47 +0000
Subject: [PATCH 074/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/merge_temporal_splits.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 91dfecf874..96c1e0bfe1 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 import numpy as np
 
+
 def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None):
     """
     Compute the presence distance between two units.

From 852521ca7433a59193cb24a687d6753b4b60a18d Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 13:06:09 +0200
Subject: [PATCH 075/164] WIP

---
 .../sortingcomponents/merging/circus.py         | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 481301c1fa..e4f4a70ed5 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -20,18 +20,15 @@ class CircusMerging(BaseMergingEngine):
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
-            "template_metric": "cosine",
-            "firing_contamination_balance": 0.5,
-            "num_channels": 5,
-            "num_shift": 5,
+            "maximum_distance_um" : 10,
+            "presence_distance_thresh": 100,
+            "template_diff_thresh" : 1,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
-            "presence_distance_threshold": 0.1,
-            "firing_contamination_balance": 0.5,
-            "template_metric": "l1",
-            "num_channels": 5,
-            "num_shift": 5,
+            "maximum_distance_um" : 10,
+            "presence_distance_thresh": 100,
+            "template_diff_thresh" : 1,
         },
     }
 
@@ -67,7 +64,7 @@ def run(self, extra_outputs=False):
             print(f"{len(merges)} merges have been detected via auto merges")
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
-            merges += get_potential_temporal_splits(self.analyzer, **temporal_splits_kwargs)
+            merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset='temporal_splits')
             if self.verbose:
                 print(f"{len(merges)} merges have been detected via additional temporal splits")
         merges = resolve_merging_graph(self.sorting, merges)

From c9cbd9e5876229a0d67600fd8ca45b646da73e64 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 13 Jun 2024 11:15:23 +0000
Subject: [PATCH 076/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index e4f4a70ed5..450b9fd160 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -20,15 +20,15 @@ class CircusMerging(BaseMergingEngine):
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
-            "maximum_distance_um" : 10,
+            "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
-            "template_diff_thresh" : 1,
+            "template_diff_thresh": 1,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um" : 10,
+            "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
-            "template_diff_thresh" : 1,
+            "template_diff_thresh": 1,
         },
     }
 
@@ -64,7 +64,7 @@ def run(self, extra_outputs=False):
             print(f"{len(merges)} merges have been detected via auto merges")
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
-            merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset='temporal_splits')
+            merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
             if self.verbose:
                 print(f"{len(merges)} merges have been detected via additional temporal splits")
         merges = resolve_merging_graph(self.sorting, merges)

From 476fc31eb2b7d112424e1d6e2104ef0318751080 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 13:15:58 +0200
Subject: [PATCH 077/164] Useless imports

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index e4f4a70ed5..591b9f6c8f 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -5,7 +5,6 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.curation.merge_temporal_splits import get_potential_temporal_splits
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 

From b2f2e8ac482d626e1a79a8cb97d8f11e5d940a07 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 13:22:54 +0200
Subject: [PATCH 078/164] Delete Untitled.ipynb

---
 Untitled.ipynb | 218 -------------------------------------------------
 1 file changed, 218 deletions(-)
 delete mode 100644 Untitled.ipynb

diff --git a/Untitled.ipynb b/Untitled.ipynb
deleted file mode 100644
index ea2096f3ef..0000000000
--- a/Untitled.ipynb
+++ /dev/null
@@ -1,218 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "5e1b6eef-89ab-4e4f-a67f-8e310479b663",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "import spikeinterface.full as si"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f64332b1-160d-453a-b423-029b7159a39f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/pierre/github/spikeinterface/src/spikeinterface/core/generate.py:1947: UserWarning: generate_unit_locations(): no solution for minimum_distance=20 and max_iteration=100\n",
-      "  warnings.warn(f\"generate_unit_locations(): no solution for {minimum_distance=} and {max_iteration=}\")\n",
-      "/home/pierre/github/spikeinterface/src/spikeinterface/core/job_tools.py:103: UserWarning: `n_jobs` is not set so parallel processing is disabled! To speed up computations, it is recommended to set n_jobs either globally (with the `spikeinterface.set_global_job_kwargs()` function) or locally (with the `n_jobs` argument). Use `spikeinterface.set_global_job_kwargs?` for more information about job_kwargs.\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "87d158a7f47541cfaa056744533134ae",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "estimate_sparsity:   0%|          | 0/10 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "rec, sorting = si.generate_ground_truth_recording(num_channels=128, num_units=250)\n",
-    "sa = si.create_sorting_analyzer(sorting, rec)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "d587d6cc-8924-419f-a916-f1fb2f924cbf",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9a2f38e9ec544e479fb925643e7fa374",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "estimate_templates_with_accumulator:   0%|          | 0/10 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "si.set_global_job_kwargs(n_jobs=0.8)\n",
-    "sa.compute(['random_spikes', 'templates'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "4139775f-4b73-45c1-ba61-fbcf5b88248d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x500 with 6 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "res = {}\n",
-    "for method in ['union', 'intersection', 'dense']:\n",
-    "    print(method)\n",
-    "    res[method] = sa.compute('template_similarity', support=method, method='l1').get_data()\n",
-    "import pylab as plt\n",
-    "fig, axes = plt.subplots(2, len(res.keys()), figsize=(15, 5))\n",
-    "for count, key in enumerate(res.keys()):\n",
-    "    axes[0, count].imshow(res[key])\n",
-    "    axes[0, count].set_title(key)\n",
-    "    axes[1, count].hist(res[key].flatten(), 100)\n",
-    "    axes[1, count].set_yscale('log')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "57e30e39-de70-4b9e-858b-11f46919c87b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "union\n",
-      "intersection\n",
-      "dense\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x500 with 6 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "res = {}\n",
-    "for method in ['union', 'intersection', 'dense']:\n",
-    "    print(method)\n",
-    "    res[method] = sa.compute('template_similarity', support=method, method='l2').get_data()\n",
-    "import pylab as plt\n",
-    "fig, axes = plt.subplots(2, len(res.keys()), figsize=(15, 5))\n",
-    "for count, key in enumerate(res.keys()):\n",
-    "    axes[0, count].imshow(res[key])\n",
-    "    axes[0, count].set_title(key)\n",
-    "    axes[1, count].hist(res[key].flatten(), 100)\n",
-    "    axes[1, count].set_yscale('log')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "09205f26-0aaf-4808-a138-c723f22180f7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "union\n",
-      "intersection\n",
-      "dense\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x500 with 6 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "res = {}\n",
-    "for method in ['union', 'intersection', 'dense']:\n",
-    "    print(method)\n",
-    "    res[method] = sa.compute('template_similarity', support=method, method='cosine').get_data()\n",
-    "import pylab as plt\n",
-    "fig, axes = plt.subplots(2, len(res.keys()), figsize=(15, 5))\n",
-    "for count, key in enumerate(res.keys()):\n",
-    "    axes[0, count].imshow(res[key])\n",
-    "    axes[0, count].set_title(key)\n",
-    "    axes[1, count].hist(res[key].flatten(), 100)\n",
-    "    axes[1, count].set_yscale('log')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dfbb6506-ba5f-438a-a0c9-49957b4b58bf",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

From e7f66550847aa863ff6819fd57241cdbc80505d9 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 13:25:28 +0200
Subject: [PATCH 079/164] Docs

---
 src/spikeinterface/curation/auto_merge.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index e79f572196..6c255b15b3 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -293,7 +293,7 @@ def get_potential_auto_merge(
 
 
 def compute_correlogram_diff(
-    sorting, correlograms_smoothed, bins, win_sizes, adaptative_window_threshold=0.5, pair_mask=None
+    sorting, correlograms_smoothed, win_sizes, adaptative_window_threshold=0.5, pair_mask=None
 ):
     """
     Original author: Aurelien Wyngaard (lussac)
@@ -305,9 +305,7 @@ def compute_correlogram_diff(
     correlograms_smoothed : array 3d
         The 3d array containing all cross and auto correlograms
         (smoothed by a convolution with a gaussian curve)
-    bins : array
-        Bins of the correlograms
-    win_sized:
+    win_sizes:
         TODO
     adaptative_window_threshold : float
         TODO

From 640446a10d4b8f8fa9145758202a823f3674bf48 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 16:12:48 +0200
Subject: [PATCH 080/164] Cleaning auto merge

---
 src/spikeinterface/curation/auto_merge.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 6c255b15b3..1375c94212 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -219,7 +219,6 @@ def get_potential_auto_merge(
             correlograms_smoothed,
             bins,
             win_sizes,
-            adaptative_window_threshold=adaptative_window_threshold,
             pair_mask=pair_mask,
         )
         # print(correlogram_diff)
@@ -293,7 +292,7 @@ def get_potential_auto_merge(
 
 
 def compute_correlogram_diff(
-    sorting, correlograms_smoothed, win_sizes, adaptative_window_threshold=0.5, pair_mask=None
+    sorting, correlograms_smoothed, win_sizes, pair_mask=None
 ):
     """
     Original author: Aurelien Wyngaard (lussac)
@@ -307,8 +306,6 @@ def compute_correlogram_diff(
         (smoothed by a convolution with a gaussian curve)
     win_sizes:
         TODO
-    adaptative_window_threshold : float
-        TODO
     pair_mask : None or boolean array
         A bool matrix of size (num_units, num_units) to select
         which pair to compute.

From 7f6ed93d1f943663b29ff8c9a9df68ca25cb0961 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 13 Jun 2024 14:15:52 +0000
Subject: [PATCH 081/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 1375c94212..5e9a9777c2 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -291,9 +291,7 @@ def get_potential_auto_merge(
         return potential_merges
 
 
-def compute_correlogram_diff(
-    sorting, correlograms_smoothed, win_sizes, pair_mask=None
-):
+def compute_correlogram_diff(sorting, correlograms_smoothed, win_sizes, pair_mask=None):
     """
     Original author: Aurelien Wyngaard (lussac)
 

From f201f71bd57281d39dc226271a557719a5dc751a Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 16:21:39 +0200
Subject: [PATCH 082/164] WIP

---
 src/spikeinterface/curation/auto_merge.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 1375c94212..40186012dc 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -217,7 +217,6 @@ def get_potential_auto_merge(
         correlogram_diff = compute_correlogram_diff(
             sorting,
             correlograms_smoothed,
-            bins,
             win_sizes,
             pair_mask=pair_mask,
         )

From 6098de88023e5f0225de0e0314c4bab48582cfbd Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Thu, 13 Jun 2024 16:38:53 +0200
Subject: [PATCH 083/164] Refactoring auto merges

---
 src/spikeinterface/curation/auto_merge.py | 208 +++++++++++-----------
 1 file changed, 104 insertions(+), 104 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 373275e77c..340c52c9cb 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -109,7 +109,7 @@ def get_potential_auto_merge(
         If True, an additional dictionary (`outs`) with processed data is returned
     steps : None or list of str, default: None
         which steps to run (gives flexibility to running just some steps)
-        If None all steps are done.
+        If None all steps are done (except presence_distance).
         Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram",
         "template_similarity", "presence_distance", "check_increase_score".
         Please check steps explanations above!
@@ -137,6 +137,9 @@ def get_potential_auto_merge(
     #    * auto correlogram is contaminated
     #    * to far away one from each other
 
+    all_steps = ["min_spikes", "remove_contaminated", "unit_positions", "correlogram",
+        "template_similarity", "presence_distance", "check_increase_score"]
+
     if steps is None:
         if preset is None:
             steps = [
@@ -156,128 +159,125 @@ def get_potential_auto_merge(
                 "template_similarity",
                 "presence_distance",
                 "check_increase_score",
-            ]
+            ]       
 
     n = unit_ids.size
     pair_mask = np.ones((n, n), dtype="bool")
+    outs = dict()
 
-    if extra_outputs:
-        outs = dict()
-
-    # STEP 1 :
-    if "min_spikes" in steps:
-        num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
-        to_remove = num_spikes < minimum_spikes
-        pair_mask[to_remove, :] = False
-        pair_mask[:, to_remove] = False
-
-    # STEP 2 : remove contaminated auto corr
-    if "remove_contaminated" in steps:
-        contaminations, nb_violations = compute_refrac_period_violations(
-            sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
-        )
-        nb_violations = np.array(list(nb_violations.values()))
-        contaminations = np.array(list(contaminations.values()))
-        to_remove = contaminations > contamination_threshold
-        pair_mask[to_remove, :] = False
-        pair_mask[:, to_remove] = False
-
-    # STEP 3 : unit positions are estimated roughly with channel
-    if "unit_positions" in steps:
-        positions_ext = sorting_analyzer.get_extension("unit_locations")
-        if positions_ext is not None:
-            unit_locations = positions_ext.get_data()[:, :2]
-        else:
-            chan_loc = sorting_analyzer.get_channel_locations()
-            unit_max_chan = get_template_extremum_channel(
-                sorting_analyzer, peak_sign=peak_sign, mode="extremum", outputs="index"
-            )
-            unit_max_chan = list(unit_max_chan.values())
-            unit_locations = chan_loc[unit_max_chan, :]
+    for step in steps:
+
+        assert (step in all_steps), f"{step} is not a valid step"
 
-        unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
-        pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
+        # STEP 1 :
+        if step == "min_spikes":
+            num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
+            to_remove = num_spikes < minimum_spikes
+            pair_mask[to_remove, :] = False
+            pair_mask[:, to_remove] = False
 
-        if extra_outputs:
+        # STEP 2 : remove contaminated auto corr
+        elif step == "remove_contaminated":
+            contaminations, nb_violations = compute_refrac_period_violations(
+                sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
+            )
+            nb_violations = np.array(list(nb_violations.values()))
+            contaminations = np.array(list(contaminations.values()))
+            to_remove = contaminations > contamination_threshold
+            pair_mask[to_remove, :] = False
+            pair_mask[:, to_remove] = False
+
+        # STEP 3 : unit positions are estimated roughly with channel
+        elif step == "unit_positions" in steps:
+            positions_ext = sorting_analyzer.get_extension("unit_locations")
+            if positions_ext is not None:
+                unit_locations = positions_ext.get_data()[:, :2]
+            else:
+                chan_loc = sorting_analyzer.get_channel_locations()
+                unit_max_chan = get_template_extremum_channel(
+                    sorting_analyzer, peak_sign=peak_sign, mode="extremum", outputs="index"
+                )
+                unit_max_chan = list(unit_max_chan.values())
+                unit_locations = chan_loc[unit_max_chan, :]
+
+            unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
+            pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
             outs["unit_distances"] = unit_distances
 
-    # STEP 4 : potential auto merge by correlogram
-    if "correlogram" in steps:
-        correlograms, bins = compute_correlograms(sorting, window_ms=window_ms, bin_ms=bin_ms, method="numba")
-        mask = (bins[:-1] >= -censor_correlograms_ms) & (bins[:-1] < censor_correlograms_ms)
-        correlograms[:, :, mask] = 0
-        correlograms_smoothed = smooth_correlogram(correlograms, bins, sigma_smooth_ms=sigma_smooth_ms)
-        # find correlogram window for each units
-        win_sizes = np.zeros(n, dtype=int)
-        for unit_ind in range(n):
-            auto_corr = correlograms_smoothed[unit_ind, unit_ind, :]
-            thresh = np.max(auto_corr) * adaptative_window_threshold
-            win_size = get_unit_adaptive_window(auto_corr, thresh)
-            win_sizes[unit_ind] = win_size
-        correlogram_diff = compute_correlogram_diff(
-            sorting,
-            correlograms_smoothed,
-            win_sizes,
-            pair_mask=pair_mask,
-        )
-        # print(correlogram_diff)
-        pair_mask = pair_mask & (correlogram_diff < corr_diff_thresh)
-        if extra_outputs:
+        # STEP 4 : potential auto merge by correlogram
+        elif step == "correlogram" in steps:
+            correlograms_ext = sorting_analyzer.get_extension('correlograms')
+            if correlograms_ext is not None:
+                correlograms, bins = correlograms_ext.get_data()
+            else:
+                correlograms, bins = compute_correlograms(sorting, window_ms=window_ms, bin_ms=bin_ms, method="numba")
+            mask = (bins[:-1] >= -censor_correlograms_ms) & (bins[:-1] < censor_correlograms_ms)
+            correlograms[:, :, mask] = 0
+            correlograms_smoothed = smooth_correlogram(correlograms, bins, sigma_smooth_ms=sigma_smooth_ms)
+            # find correlogram window for each units
+            win_sizes = np.zeros(n, dtype=int)
+            for unit_ind in range(n):
+                auto_corr = correlograms_smoothed[unit_ind, unit_ind, :]
+                thresh = np.max(auto_corr) * adaptative_window_threshold
+                win_size = get_unit_adaptive_window(auto_corr, thresh)
+                win_sizes[unit_ind] = win_size
+            correlogram_diff = compute_correlogram_diff(
+                sorting,
+                correlograms_smoothed,
+                win_sizes,
+                pair_mask=pair_mask,
+            )
+            # print(correlogram_diff)
+            pair_mask = pair_mask & (correlogram_diff < corr_diff_thresh)
             outs["correlograms"] = correlograms
             outs["bins"] = bins
             outs["correlograms_smoothed"] = correlograms_smoothed
             outs["correlogram_diff"] = correlogram_diff
             outs["win_sizes"] = win_sizes
 
-    # STEP 5 : check if potential merge with CC also have template similarity
-    if "template_similarity" in steps:
-        templates_ext = sorting_analyzer.get_extension("templates")
-        assert (
-            templates_ext is not None
-        ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
-
-        template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
-        if template_similarity_ext is not None:
-            templates_similarity = template_similarity_ext.get_data()
-            templates_diff = 1 - templates_similarity
-
-        else:
-            templates_array = templates_ext.get_data(outputs="numpy")
-
-            templates_diff = compute_templates_diff(
-                sorting,
-                templates_array,
-                num_channels=num_channels,
-                num_shift=num_shift,
-                pair_mask=pair_mask,
-                template_metric=template_metric,
-                sparsity=sorting_analyzer.sparsity,
-            )
-
-        pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+        # STEP 5 : check if potential merge with CC also have template similarity
+        elif step == "template_similarity" in steps:
+            template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
+            if template_similarity_ext is not None:
+                templates_similarity = template_similarity_ext.get_data()
+                templates_diff = 1 - templates_similarity
 
-        if extra_outputs:
+            else:
+                templates_ext = sorting_analyzer.get_extension("templates")
+                assert (
+                    templates_ext is not None
+                ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
+                templates_array = templates_ext.get_data(outputs="numpy")
+
+                templates_diff = compute_templates_diff(
+                    sorting,
+                    templates_array,
+                    num_channels=num_channels,
+                    num_shift=num_shift,
+                    pair_mask=pair_mask,
+                    template_metric=template_metric,
+                    sparsity=sorting_analyzer.sparsity,
+                )
+
+            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
             outs["templates_diff"] = templates_diff
 
-    # STEP 6 : [optional] check how the rates overlap in times
-    if "presence_distance" in steps:
-        presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
-        pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
-
-        if extra_outputs:
+        # STEP 6 : [optional] check how the rates overlap in times
+        elif step == "presence_distance" in steps:
+            presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
+            pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
             outs["presence_distances"] = presence_distances
 
-    # STEP 7 : validate the potential merges with CC increase the contamination quality metrics
-    if "check_increase_score" in steps:
-        pair_mask, pairs_decreased_score = check_improve_contaminations_score(
-            sorting_analyzer,
-            pair_mask,
-            contaminations,
-            firing_contamination_balance,
-            refractory_period_ms,
-            censored_period_ms,
-        )
-        if extra_outputs:
+        # STEP 7 : validate the potential merges with CC increase the contamination quality metrics
+        elif step == "check_increase_score" in steps:
+            pair_mask, pairs_decreased_score = check_improve_contaminations_score(
+                sorting_analyzer,
+                pair_mask,
+                contaminations,
+                firing_contamination_balance,
+                refractory_period_ms,
+                censored_period_ms,
+            )
             outs["pairs_decreased_score"] = pairs_decreased_score
 
     # FINAL STEP : create the final list from pair_mask boolean matrix

From 1a29125ab21d7b736cb8df74bc220c3e1a63167c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 13 Jun 2024 14:42:04 +0000
Subject: [PATCH 084/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 340c52c9cb..2c63be63ab 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -137,8 +137,15 @@ def get_potential_auto_merge(
     #    * auto correlogram is contaminated
     #    * to far away one from each other
 
-    all_steps = ["min_spikes", "remove_contaminated", "unit_positions", "correlogram",
-        "template_similarity", "presence_distance", "check_increase_score"]
+    all_steps = [
+        "min_spikes",
+        "remove_contaminated",
+        "unit_positions",
+        "correlogram",
+        "template_similarity",
+        "presence_distance",
+        "check_increase_score",
+    ]
 
     if steps is None:
         if preset is None:
@@ -159,7 +166,7 @@ def get_potential_auto_merge(
                 "template_similarity",
                 "presence_distance",
                 "check_increase_score",
-            ]       
+            ]
 
     n = unit_ids.size
     pair_mask = np.ones((n, n), dtype="bool")
@@ -167,7 +174,7 @@ def get_potential_auto_merge(
 
     for step in steps:
 
-        assert (step in all_steps), f"{step} is not a valid step"
+        assert step in all_steps, f"{step} is not a valid step"
 
         # STEP 1 :
         if step == "min_spikes":
@@ -206,7 +213,7 @@ def get_potential_auto_merge(
 
         # STEP 4 : potential auto merge by correlogram
         elif step == "correlogram" in steps:
-            correlograms_ext = sorting_analyzer.get_extension('correlograms')
+            correlograms_ext = sorting_analyzer.get_extension("correlograms")
             if correlograms_ext is not None:
                 correlograms, bins = correlograms_ext.get_data()
             else:

From 80f914d25b1a5ff9d6f12287adefb0fa668fa3e5 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 14 Jun 2024 06:37:10 +0200
Subject: [PATCH 085/164] Tests

---
 .../benchmark/tests/test_benchmark_merging.py               | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
index 7844f38ed7..d3c6e37539 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/tests/test_benchmark_merging.py
@@ -4,14 +4,14 @@
 
 import shutil
 
-from spikeinterface.sortingcomponents.benchmark.tests.common_benchmark_testing import make_dataset, cache_folder
+from spikeinterface.sortingcomponents.benchmark.tests.common_benchmark_testing import make_dataset
 from spikeinterface.sortingcomponents.benchmark.benchmark_merging import MergingStudy
 from spikeinterface.generation.drift_tools import split_sorting_by_amplitudes, split_sorting_by_times
 
 
 @pytest.mark.skip()
-def test_benchmark_merging():
-
+def test_benchmark_merging(create_cache_folder):
+    cache_folder = create_cache_folder
     job_kwargs = dict(n_jobs=0.8, chunk_duration="1s")
 
     recording, gt_sorting, gt_analyzer = make_dataset()

From 0056eafe6bb84094307c8fbbd055a69a927de311 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 14 Jun 2024 15:07:03 +0200
Subject: [PATCH 086/164] Adding the extra method from Aurelien as a step in
 auto_merge for clarity

---
 src/spikeinterface/curation/auto_merge.py     |  73 ++++++++-
 .../sortingcomponents/merging/circus.py       |  12 +-
 .../sortingcomponents/merging/lussac.py       | 147 ++----------------
 3 files changed, 93 insertions(+), 139 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 2c63be63ab..6135a815e7 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -35,6 +35,8 @@ def get_potential_auto_merge(
     presence_distance_thresh=100,
     preset=None,
     template_metric="l1",
+    p_value=0.2,
+    CC_threshold=0.1,
     **presence_distance_kwargs,
 ):
     """
@@ -52,7 +54,8 @@ def get_potential_auto_merge(
         * STEP 4: the cross-correlograms of the two units are similar to each auto-corrleogram (`corr_diff_thresh`)
         * STEP 5: the templates of the two units are similar (`template_diff_thresh`)
         * STEP 6: [optional] the presence distance of two units
-        * STEP 7: the unit "quality score" is increased after the merge.
+        * STEP 7: [optional] the cross-contamination is not significant
+        * STEP 8: the unit "quality score" is increased after the merge.
 
     The "quality score" factors in the increase in firing rate (**f**) due to the merge and a possible increase in
     contamination (**C**), wheighted by a factor **k** (`firing_contamination_balance`).
@@ -144,6 +147,7 @@ def get_potential_auto_merge(
         "correlogram",
         "template_similarity",
         "presence_distance",
+        "cross_contamination",
         "check_increase_score",
     ]
 
@@ -167,6 +171,15 @@ def get_potential_auto_merge(
                 "presence_distance",
                 "check_increase_score",
             ]
+        elif preset == "lussac":
+            steps = [
+                "min_spikes",
+                "remove_contaminated",
+                "unit_positions",
+                "template_similarity",
+                "cross_contamination",
+                "check_increase_score",
+            ]
 
     n = unit_ids.size
     pair_mask = np.ones((n, n), dtype="bool")
@@ -274,8 +287,15 @@ def get_potential_auto_merge(
             presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
             pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
             outs["presence_distances"] = presence_distances
-
-        # STEP 7 : validate the potential merges with CC increase the contamination quality metrics
+        
+        # STEP 7 : [optional] check if the cross contamination is significant
+        elif step == "cross_contamination" in steps:
+            refractory = (censored_period_ms, refractory_period_ms)
+            CC, p_values = compute_cross_contaminations(sorting_analyzer, pair_mask, CC_threshold, refractory)
+            pair_mask = pair_mask & (p_values > p_value)
+            outs["cross_contaminations"] = CC, p_values
+
+        # STEP 8 : validate the potential merges with CC increase the contamination quality metrics
         elif step == "check_increase_score" in steps:
             pair_mask, pairs_decreased_score = check_improve_contaminations_score(
                 sorting_analyzer,
@@ -439,6 +459,53 @@ def get_unit_adaptive_window(auto_corr: np.ndarray, threshold: float):
     return win_size
 
 
+def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_period):
+    """
+    Looks at a sorting analyzer, and returns statistical tests for cross_contaminations
+
+    Parameters
+    ----------
+    analyzer : SortingAnalyzer
+        The analyzer to look at
+    CC_treshold : float, default: 0.1
+        The threshold on the cross-contamination.
+        Any pair above this threshold will not be considered.
+    refractory_period : array/list/tuple of 2 floats
+        (censored_period_ms, refractory_period_ms)
+    
+    """
+
+    sorting = analyzer.sorting
+    unit_ids = sorting.unit_ids
+    n = len(unit_ids)
+    sf = analyzer.recording.sampling_frequency
+    n_frames = analyzer.recording.get_num_samples()
+    from spikeinterface.sortingcomponents.merging.lussac import estimate_cross_contamination
+    
+    if pair_mask is None:
+        pair_mask = np.ones((n, n), dtype="bool")
+
+    CC = np.zeros((n, n), dtype=np.float32)
+    p_values = np.zeros((n, n), dtype=np.float32)
+
+    for unit_ind1 in range(len(unit_ids)):
+
+        unit_id1 = unit_ids[unit_ind1]
+        spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
+
+        for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
+            if not pair_mask[unit_ind1, unit_ind2]:
+                continue
+            
+            unit_id2 = unit_ids[unit_ind2]
+            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
+            # Compuyting the cross-contamination difference
+            CC[unit_ind1, unit_ind2], p_values[unit_ind1, unit_ind2] = estimate_cross_contamination(
+                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
+            )
+        
+    return CC, p_values
+
 def compute_templates_diff(
     sorting, templates_array, num_channels=5, num_shift=5, pair_mask=None, template_metric="l1", sparsity=None
 ):
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index dae8fcdf9f..4570bf36cc 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -15,19 +15,24 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose": False,
+        "verbose": True,
+        "metric_kwargs" : {"method" : "cosine", "support" : "union", "max_lag_ms" : 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
             "template_diff_thresh": 1,
+            "bin_ms" : 1,
+            "window_ms": 250
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
             "template_diff_thresh": 1,
+            "bin_ms" : 1,
+            "window_ms": 250
         },
     }
 
@@ -51,7 +56,10 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        self.analyzer.compute("template_similarity")
+        self.analyzer.compute("template_similarity", 
+                              method='l1', 
+                              support='union', 
+                              max_lag_ms=0.2)
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.params.get("curation_kwargs", None)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index ddcc800aec..5a3dd39373 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,6 +12,7 @@
 from .main import BaseMergingEngine
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
+from spikeinterface.curation.auto_merge import get_potential_auto_merge
 from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
 
 
@@ -229,135 +230,6 @@ def estimate_cross_contamination(
     return estimation, p_value
 
 
-def lussac_merge(
-    analyzer,
-    refractory_period,
-    minimum_spikes=50,
-    template_diff_thresh: float = 0.25,
-    CC_threshold: float = 0.2,
-    max_shift: int = 5,
-    num_channels: int = 5,
-    template_metric="l1",
-    p_value: float = 0.2,
-) -> list[tuple]:
-    """
-    Looks at a sorting analyzer, and returns a list of potential pairwise merges.
-
-    Parameters
-    ----------
-    analyzer : SortingAnalyzer
-        The analyzer to look at
-    refractory_period : array/list/tuple of 2 floats
-        (censored_period_ms, refractory_period_ms)
-    minimum_spikes : int, default: 100
-        Minimum number of spikes for each unit to consider a potential merge.
-    template_diff_thresh : float
-        The threshold on the template difference.
-        Any pair above this threshold will not be considered.
-    CC_treshold : float
-        The threshold on the cross-contamination.
-        Any pair above this threshold will not be considered.
-    max_shift : int
-        The maximum shift when comparing the templates (in number of time samples).
-    max_channels : int
-        The maximum number of channels to consider when comparing the templates.
-    p_value : float, default: 0.2
-        The minimal p_value to be considered for putative merges
-    """
-
-    assert HAVE_NUMBA, "Numba should be installed"
-    sorting = analyzer.sorting
-    potential_merges = []
-    sf = analyzer.recording.sampling_frequency
-    n_frames = analyzer.recording.get_num_samples()
-    sparsity = analyzer.sparsity
-    all_shifts = range(-max_shift, max_shift + 1)
-    unit_ids = sorting.unit_ids
-
-    template_similarities = analyzer.get_extension("template_similarity")
-    if template_similarities is not None:
-        template_diff_thresh = 1 - template_diff_thresh
-
-    if sparsity is None:
-        adaptative_masks = False
-        sparsity_mask = None
-    else:
-        adaptative_masks = num_channels == None
-        sparsity_mask = sparsity.mask
-
-    for unit_ind1 in range(len(unit_ids)):
-
-        unit_id1 = unit_ids[unit_ind1]
-        spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
-        if not len(spike_train1) > minimum_spikes:
-            continue
-        template1 = analyzer.get_extension("templates").get_unit_template(unit_id1)
-
-        for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
-
-            unit_id2 = unit_ids[unit_ind2]
-
-            # Checking that we have enough spikes
-            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
-            if not len(spike_train2) > minimum_spikes:
-                continue
-
-            # Computing template difference
-            template2 = analyzer.get_extension("templates").get_unit_template(unit_id2)
-
-            if template_similarities is not None:
-                max_diff = template_similarities.get_data()[unit_ind1, unit_ind2]
-            else:
-
-                if not adaptative_masks:
-                    chan_inds = np.argsort(np.max(np.abs(template1) + np.abs(template2), axis=0))[::-1][:num_channels]
-                else:
-                    chan_inds = np.flatnonzero(sparsity_mask[unit_ind1] * sparsity_mask[unit_ind2])
-
-                if len(chan_inds) > 0:
-                    template1 = template1[:, chan_inds]
-                    template2 = template2[:, chan_inds]
-
-                    if template_metric == "l1":
-                        norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
-                    elif template_metric == "l2":
-                        norm = np.sum(template1**2) + np.sum(template2**2)
-                    elif template_metric == "cosine":
-                        norm = np.linalg.norm(template1) * np.linalg.norm(template2)
-
-                    all_shift_diff = []
-                    n = len(template1)
-                    for shift in all_shifts:
-                        temp1 = template1[max_shift : n - max_shift, :]
-                        temp2 = template2[max_shift + shift : n - max_shift + shift, :]
-                        if template_metric == "l1":
-                            d = np.sum(np.abs(temp1 - temp2)) / norm
-                        elif template_metric == "l2":
-                            d = np.linalg.norm(temp1 - temp2) / norm
-                        elif template_metric == "cosine":
-                            d = 1 - np.sum(temp1 * temp2) / norm
-                        all_shift_diff.append(d)
-                else:
-                    all_shift_diff = [1] * len(all_shifts)
-
-                max_diff = np.min(all_shift_diff)
-
-            if max_diff > template_diff_thresh:
-                continue
-
-            # Compuyting the cross-contamination difference
-            CC, p = estimate_cross_contamination(
-                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
-            )
-
-            if p < p_value:
-                continue
-
-            potential_merges.append((unit_id1, unit_id2))
-
-    return potential_merges
-
-
 class LussacMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric
@@ -365,10 +237,13 @@ class LussacMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "minimum_spikes": 50,
-        "refractory_period": (0.3, 1.0),
-        "template_diff_thresh": 0.3,
         "verbose": True,
+        "lussac_kwargs": {
+            "minimum_spikes": 50,
+            "maximum_distance_um" : 10,
+            "refractory_period": (0.3, 1.0),
+            "template_diff_thresh": 0.5,
+        }
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -391,10 +266,14 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        self.analyzer.compute("template_similarity")
+        self.analyzer.compute("template_similarity", 
+                              method='cosine', 
+                              support='union', 
+                              max_lag_ms=0.2)
 
     def run(self, extra_outputs=False):
-        merges = lussac_merge(self.analyzer, **self.params)
+        lussac_kwargs = self.params.get("lussac_kwargs", None)
+        merges = get_potential_auto_merge(self.analyzer, **lussac_kwargs, preset="lussac")
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         merges = resolve_merging_graph(self.sorting, merges)

From 75a88043e65ae86fb28e4ba5cadd80904be55a0a Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 14 Jun 2024 13:07:39 +0000
Subject: [PATCH 087/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py         | 11 ++++++-----
 .../sortingcomponents/merging/circus.py           | 15 ++++++---------
 .../sortingcomponents/merging/lussac.py           |  9 +++------
 3 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 6135a815e7..dbb964abe8 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -287,7 +287,7 @@ def get_potential_auto_merge(
             presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
             pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
             outs["presence_distances"] = presence_distances
-        
+
         # STEP 7 : [optional] check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
             refractory = (censored_period_ms, refractory_period_ms)
@@ -472,7 +472,7 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
         Any pair above this threshold will not be considered.
     refractory_period : array/list/tuple of 2 floats
         (censored_period_ms, refractory_period_ms)
-    
+
     """
 
     sorting = analyzer.sorting
@@ -481,7 +481,7 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
     sf = analyzer.recording.sampling_frequency
     n_frames = analyzer.recording.get_num_samples()
     from spikeinterface.sortingcomponents.merging.lussac import estimate_cross_contamination
-    
+
     if pair_mask is None:
         pair_mask = np.ones((n, n), dtype="bool")
 
@@ -496,16 +496,17 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
         for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
             if not pair_mask[unit_ind1, unit_ind2]:
                 continue
-            
+
             unit_id2 = unit_ids[unit_ind2]
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
             # Compuyting the cross-contamination difference
             CC[unit_ind1, unit_ind2], p_values[unit_ind1, unit_ind2] = estimate_cross_contamination(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
             )
-        
+
     return CC, p_values
 
+
 def compute_templates_diff(
     sorting, templates_array, num_channels=5, num_shift=5, pair_mask=None, template_metric="l1", sparsity=None
 ):
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4570bf36cc..bbb3c6ae35 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,23 +16,23 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "metric_kwargs" : {"method" : "cosine", "support" : "union", "max_lag_ms" : 0.2},
+        "metric_kwargs": {"method": "cosine", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
             "template_diff_thresh": 1,
-            "bin_ms" : 1,
-            "window_ms": 250
+            "bin_ms": 1,
+            "window_ms": 250,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
             "template_diff_thresh": 1,
-            "bin_ms" : 1,
-            "window_ms": 250
+            "bin_ms": 1,
+            "window_ms": 250,
         },
     }
 
@@ -56,10 +56,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        self.analyzer.compute("template_similarity", 
-                              method='l1', 
-                              support='union', 
-                              max_lag_ms=0.2)
+        self.analyzer.compute("template_similarity", method="l1", support="union", max_lag_ms=0.2)
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.params.get("curation_kwargs", None)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 5a3dd39373..c1e14e9761 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -240,10 +240,10 @@ class LussacMerging(BaseMergingEngine):
         "verbose": True,
         "lussac_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um" : 10,
+            "maximum_distance_um": 10,
             "refractory_period": (0.3, 1.0),
             "template_diff_thresh": 0.5,
-        }
+        },
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -266,10 +266,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        self.analyzer.compute("template_similarity", 
-                              method='cosine', 
-                              support='union', 
-                              max_lag_ms=0.2)
+        self.analyzer.compute("template_similarity", method="cosine", support="union", max_lag_ms=0.2)
 
     def run(self, extra_outputs=False):
         lussac_kwargs = self.params.get("lussac_kwargs", None)

From 8afab015a436838a59ff6047593832c452239dcf Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 14 Jun 2024 15:12:49 +0200
Subject: [PATCH 088/164] Factorize params

---
 .../sortingcomponents/merging/circus.py              | 12 ++++++------
 .../sortingcomponents/merging/lussac.py              |  7 ++++---
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4570bf36cc..3c076d0dde 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,13 +16,15 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "metric_kwargs" : {"method" : "cosine", "support" : "union", "max_lag_ms" : 0.2},
+        "similarity_kwargs" : {"method" : "cosine", 
+                               "support" : "union", 
+                               "max_lag_ms" : 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
-            "template_diff_thresh": 1,
+            "template_diff_thresh": 0.5,
             "bin_ms" : 1,
             "window_ms": 250
         },
@@ -30,7 +32,7 @@ class CircusMerging(BaseMergingEngine):
             "minimum_spikes": 50,
             "maximum_distance_um": 10,
             "presence_distance_thresh": 100,
-            "template_diff_thresh": 1,
+            "template_diff_thresh": 0.5,
             "bin_ms" : 1,
             "window_ms": 250
         },
@@ -57,9 +59,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
         self.analyzer.compute("template_similarity", 
-                              method='l1', 
-                              support='union', 
-                              max_lag_ms=0.2)
+                              **self.params['similarity_kwargs'])
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.params.get("curation_kwargs", None)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 5a3dd39373..649ff3c041 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -238,6 +238,9 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
+        "similarity_kwargs" : {"method" : "cosine", 
+                               "support" : "union", 
+                               "max_lag_ms" : 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um" : 10,
@@ -267,9 +270,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
         self.analyzer.compute("template_similarity", 
-                              method='cosine', 
-                              support='union', 
-                              max_lag_ms=0.2)
+                              **self.params['similarity_kwargs'])
 
     def run(self, extra_outputs=False):
         lussac_kwargs = self.params.get("lussac_kwargs", None)

From efc621ceeced89a862de8e29e08b2481f91bbc06 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 14 Jun 2024 17:08:40 +0200
Subject: [PATCH 089/164] Default params

---
 .../sortingcomponents/merging/circus.py          | 10 +++++-----
 .../sortingcomponents/merging/lussac.py          | 16 ++++++++--------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 3c076d0dde..86656d162a 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,23 +16,23 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "similarity_kwargs" : {"method" : "cosine", 
+        "similarity_kwargs" : {"method" : "l2", 
                                "support" : "union", 
                                "max_lag_ms" : 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
-            "maximum_distance_um": 10,
+            "maximum_distance_um": 20,
             "presence_distance_thresh": 100,
-            "template_diff_thresh": 0.5,
+            "template_diff_thresh": 0.3,
             "bin_ms" : 1,
             "window_ms": 250
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um": 10,
+            "maximum_distance_um": 20,
             "presence_distance_thresh": 100,
-            "template_diff_thresh": 0.5,
+            "template_diff_thresh": 0.3,
             "bin_ms" : 1,
             "window_ms": 250
         },
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 649ff3c041..c3d349382f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -204,17 +204,17 @@ def estimate_cross_contamination(
     spike_train1 = spike_train1.astype(np.int64, copy=False)
     spike_train2 = spike_train2.astype(np.int64, copy=False)
 
-    N1 = len(spike_train1)
-    N2 = len(spike_train2)
+    N1 = float(len(spike_train1))
+    N2 = float(len(spike_train2))
     C1 = estimate_contamination(spike_train1, sf, T, refractory_period)
 
-    t_c = refractory_period[0] * 1e-3 * sf
-    t_r = refractory_period[1] * 1e-3 * sf
+    t_c = int(round(refractory_period[0] * 1e-3 * sf))
+    t_r = int(round(refractory_period[1] * 1e-3 * sf))
     n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(
         spike_train1, spike_train2, t_c
     )
 
-    estimation = 1 - ((n_violations * T) / (2 * N1 * N2 * t_r) - 1) / (C1 - 1) if C1 != 1.0 else -np.inf
+    estimation = 1 - ((n_violations * T) / (2 * N1 * N2 * t_r) - 1.0) / (C1 - 1.0) if C1 != 1.0 else -np.inf
     if limit is None:
         return estimation
 
@@ -238,14 +238,14 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "similarity_kwargs" : {"method" : "cosine", 
+        "similarity_kwargs" : {"method" : "l2", 
                                "support" : "union", 
                                "max_lag_ms" : 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um" : 10,
+            "maximum_distance_um" : 20,
             "refractory_period": (0.3, 1.0),
-            "template_diff_thresh": 0.5,
+            "template_diff_thresh": 0.3,
         }
     }
 

From 2ad54dc6e93b71c8ccf7b2f335f7cb7c6afa3507 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 14 Jun 2024 15:09:52 +0000
Subject: [PATCH 090/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sortingcomponents/merging/circus.py           | 15 ++++++---------
 .../sortingcomponents/merging/lussac.py           | 11 ++++-------
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 86656d162a..d6eacf0db0 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,25 +16,23 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "similarity_kwargs" : {"method" : "l2", 
-                               "support" : "union", 
-                               "max_lag_ms" : 0.2},
+        "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "maximum_distance_um": 20,
             "presence_distance_thresh": 100,
             "template_diff_thresh": 0.3,
-            "bin_ms" : 1,
-            "window_ms": 250
+            "bin_ms": 1,
+            "window_ms": 250,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um": 20,
             "presence_distance_thresh": 100,
             "template_diff_thresh": 0.3,
-            "bin_ms" : 1,
-            "window_ms": 250
+            "bin_ms": 1,
+            "window_ms": 250,
         },
     }
 
@@ -58,8 +56,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        self.analyzer.compute("template_similarity", 
-                              **self.params['similarity_kwargs'])
+        self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
 
     def run(self, extra_outputs=False):
         curation_kwargs = self.params.get("curation_kwargs", None)
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index c3d349382f..38c27293ef 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -238,15 +238,13 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "similarity_kwargs" : {"method" : "l2", 
-                               "support" : "union", 
-                               "max_lag_ms" : 0.2},
+        "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um" : 20,
+            "maximum_distance_um": 20,
             "refractory_period": (0.3, 1.0),
             "template_diff_thresh": 0.3,
-        }
+        },
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -269,8 +267,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
-        self.analyzer.compute("template_similarity", 
-                              **self.params['similarity_kwargs'])
+        self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
 
     def run(self, extra_outputs=False):
         lussac_kwargs = self.params.get("lussac_kwargs", None)

From 435804057516d1f5500ac6f054d731a1c17f1544 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 17 Jun 2024 16:46:14 +0200
Subject: [PATCH 091/164] WIP

---
 .../sortingcomponents/merging/circus.py       |  6 ++++++
 .../sortingcomponents/merging/lussac.py       |  5 +++++
 .../sortingcomponents/merging/tools.py        | 21 +++++++++++++++++++
 3 files changed, 32 insertions(+)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index d6eacf0db0..ed2f28620d 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,6 +16,7 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
+        "remove_emtpy" : True,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
@@ -41,6 +42,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
+        self.remove_empty = self.params.get('remove_empty', True)
         self.verbose = self.params.pop("verbose")
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
@@ -56,6 +58,10 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
+        if self.remove_empty:
+            from .tools import remove_empty_units
+            self.analyzer = remove_empty_units(self.analyzer)
+
         self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 38c27293ef..de7cc799b4 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -252,6 +252,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.verbose = self.params.pop("verbose")
+        self.remove_empty = self.params.get('remove_empty', True)
         self.recording = recording
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
@@ -267,6 +268,10 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute(["random_spikes", "templates"])
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
+        if self.remove_empty:
+            from .tools import remove_empty_units
+            self.analyzer = remove_empty_units(self.analyzer)
+
         self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
index d8b3a88bdc..0d47ceadcf 100644
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -1,7 +1,28 @@
 import numpy as np
 from spikeinterface.core import NumpySorting
+from spikeinterface import SortingAnalyzer
 
 
+def remove_empty_units(
+    sorting_or_sorting_analyzer,
+    minimum_spikes = 10
+):
+    if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
+        sorting = sorting_or_sorting_analyzer.sorting
+        counts = sorting.get_total_num_spikes()
+        ids_to_select = []
+        for id, num_spikes in counts.items():
+            if num_spikes >= minimum_spikes:
+                ids_to_select += [id]
+        return sorting_or_sorting_analyzer.select_units(ids_to_select)
+    else:
+        counts = sorting_or_sorting_analyzer.get_total_num_spikes()
+        ids_to_select = []
+        for id, num_spikes in counts.items():
+            if num_spikes >= minimum_spikes:
+                ids_to_select += [id]
+        return sorting_or_sorting_analyzer.select_units(ids_to_select)
+
 def resolve_merging_graph(sorting, potential_merges):
     """
     Function to provide, given a list of potential_merges, a resolved merging

From 0a1a4004d4fe09ec0e672601d3400d23551f848d Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 17 Jun 2024 16:51:04 +0200
Subject: [PATCH 092/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index de7cc799b4..df58ba0150 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -238,6 +238,7 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
+        "remove_emtpy" : True,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,

From 4856aeb301148d38a01b1da341ddb36e17dc3f2e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 17 Jun 2024 14:53:41 +0000
Subject: [PATCH 093/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 5 +++--
 src/spikeinterface/sortingcomponents/merging/lussac.py | 5 +++--
 src/spikeinterface/sortingcomponents/merging/tools.py  | 6 ++----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index ed2f28620d..bf57d859d1 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,7 +16,7 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "remove_emtpy" : True,
+        "remove_emtpy": True,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
@@ -42,7 +42,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.recording = recording
-        self.remove_empty = self.params.get('remove_empty', True)
+        self.remove_empty = self.params.get("remove_empty", True)
         self.verbose = self.params.pop("verbose")
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
@@ -60,6 +60,7 @@ def __init__(self, recording, sorting, kwargs):
 
         if self.remove_empty:
             from .tools import remove_empty_units
+
             self.analyzer = remove_empty_units(self.analyzer)
 
         self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index df58ba0150..43e906c51b 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -238,7 +238,7 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "remove_emtpy" : True,
+        "remove_emtpy": True,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
@@ -253,7 +253,7 @@ def __init__(self, recording, sorting, kwargs):
         self.params.update(**kwargs)
         self.sorting = sorting
         self.verbose = self.params.pop("verbose")
-        self.remove_empty = self.params.get('remove_empty', True)
+        self.remove_empty = self.params.get("remove_empty", True)
         self.recording = recording
         self.templates = self.params.pop("templates", None)
         if self.templates is not None:
@@ -271,6 +271,7 @@ def __init__(self, recording, sorting, kwargs):
 
         if self.remove_empty:
             from .tools import remove_empty_units
+
             self.analyzer = remove_empty_units(self.analyzer)
 
         self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
index 0d47ceadcf..d7a8896606 100644
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -3,10 +3,7 @@
 from spikeinterface import SortingAnalyzer
 
 
-def remove_empty_units(
-    sorting_or_sorting_analyzer,
-    minimum_spikes = 10
-):
+def remove_empty_units(sorting_or_sorting_analyzer, minimum_spikes=10):
     if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
         sorting = sorting_or_sorting_analyzer.sorting
         counts = sorting.get_total_num_spikes()
@@ -23,6 +20,7 @@ def remove_empty_units(
                 ids_to_select += [id]
         return sorting_or_sorting_analyzer.select_units(ids_to_select)
 
+
 def resolve_merging_graph(sorting, potential_merges):
     """
     Function to provide, given a list of potential_merges, a resolved merging

From f8b8e6c04affd2801203bdfcdb723f01ba93b9ac Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Wed, 19 Jun 2024 08:49:55 +0200
Subject: [PATCH 094/164] WIP

---
 .../sorters/internal/spyking_circus2.py       |  2 +-
 .../sortingcomponents/merging/circus.py       | 32 ++++++++++++++---
 .../sortingcomponents/merging/lussac.py       | 34 ++++++++++++++++---
 .../sortingcomponents/merging/tools.py        |  6 ++--
 4 files changed, 61 insertions(+), 13 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index e2ec8f6ffa..a5180473e6 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -33,7 +33,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {"method": "circus"},
+        "merging": {"method": "lussac"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index bf57d859d1..5942cacdba 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,7 +16,8 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "remove_emtpy": True,
+        "remove_emtpy" : True,
+        "recursive" : False,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
@@ -45,6 +46,8 @@ def __init__(self, recording, sorting, kwargs):
         self.remove_empty = self.params.get("remove_empty", True)
         self.verbose = self.params.pop("verbose")
         self.templates = self.params.pop("templates", None)
+        self.recursive = self.params.pop("recursive", True)
+
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -65,7 +68,7 @@ def __init__(self, recording, sorting, kwargs):
 
         self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
 
-    def run(self, extra_outputs=False):
+    def _get_new_sorting(self):
         curation_kwargs = self.params.get("curation_kwargs", None)
         if curation_kwargs is not None:
             merges = get_potential_auto_merge(self.analyzer, **curation_kwargs)
@@ -78,9 +81,28 @@ def run(self, extra_outputs=False):
             merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
             if self.verbose:
                 print(f"{len(merges)} merges have been detected via additional temporal splits")
-        merges = resolve_merging_graph(self.sorting, merges)
-        sorting = apply_merges_to_sorting(self.sorting, merges)
+        merges = resolve_merging_graph(self.analyzer.sorting, merges)
+        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, merges)
+        return new_sorting
+
+    def run(self, extra_outputs=False):
+        sorting, merges = self._get_new_sorting()
+        num_merges = len(merges)
+        all_merges = [merges]
+
+        if self.recursive:
+            while num_merges > 0:
+                self.analyzer = create_sorting_analyzer(sorting, 
+                                                        self.recording, 
+                                                        format="memory")
+                self.analyzer.compute(["random_spikes", "templates"])
+                self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+                self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
+                sorting, merges = self._get_new_sorting()
+                num_merges = len(merges)
+                all_merges += [merges]
+
         if extra_outputs:
-            return sorting, merges
+            return sorting, all_merges
         else:
             return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 43e906c51b..4112b40bae 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -238,7 +238,8 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "remove_emtpy": True,
+        "remove_emtpy" : True,
+        "recursive" : False,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
@@ -256,6 +257,8 @@ def __init__(self, recording, sorting, kwargs):
         self.remove_empty = self.params.get("remove_empty", True)
         self.recording = recording
         self.templates = self.params.pop("templates", None)
+        self.recursive = self.params.pop("recursive", True)
+
         if self.templates is not None:
             sparsity = self.templates.sparsity
             templates_array = self.templates.get_dense_templates().copy()
@@ -276,14 +279,35 @@ def __init__(self, recording, sorting, kwargs):
 
         self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
 
-    def run(self, extra_outputs=False):
+    def _get_new_sorting(self):
         lussac_kwargs = self.params.get("lussac_kwargs", None)
         merges = get_potential_auto_merge(self.analyzer, **lussac_kwargs, preset="lussac")
+                
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
-        merges = resolve_merging_graph(self.sorting, merges)
-        sorting = apply_merges_to_sorting(self.sorting, merges)
+        merges = resolve_merging_graph(self.analyzer.sorting, merges)
+        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, merges)
+        return new_sorting, merges
+
+    def run(self, extra_outputs=False):
+        
+        sorting, merges = self._get_new_sorting()
+        num_merges = len(merges)
+        all_merges = [merges]
+
+        if self.recursive:
+            while num_merges > 0:
+                self.analyzer = create_sorting_analyzer(sorting, 
+                                                        self.recording, 
+                                                        format="memory")
+                self.analyzer.compute(["random_spikes", "templates"])
+                self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+                self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
+                sorting, merges = self._get_new_sorting()
+                num_merges = len(merges)
+                all_merges += [merges]
+
         if extra_outputs:
-            return sorting, merges
+            return sorting, all_merges
         else:
             return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
index d7a8896606..d86191987d 100644
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -78,10 +78,12 @@ def apply_merges_to_sorting(sorting, merges, censor_ms=0.4):
         s0, s1 = segment_slices[segment_index]
         if censor_ms is not None:
             times_list += [spikes["sample_index"][s0:s1][to_keep[s0:s1]]]
-            labels_list += [spikes["unit_index"][s0:s1][to_keep[s0:s1]]]
+            unit_indices = spikes["unit_index"][s0:s1][to_keep[s0:s1]]
+            labels_list += [sorting.unit_ids[unit_indices]]
         else:
             times_list += [spikes["sample_index"][s0:s1]]
-            labels_list += [spikes["unit_index"][s0:s1]]
+            unit_indices = spikes["unit_index"][s0:s1]
+            labels_list += [sorting.unit_ids[unit_indices]]
 
     sorting = NumpySorting.from_times_labels(times_list, labels_list, sorting.sampling_frequency)
     return sorting

From e64542f0f55ddeb23cb4db1f9a10c27db4ca2cc3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 19 Jun 2024 06:53:31 +0000
Subject: [PATCH 095/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .../sortingcomponents/merging/circus.py              |  8 +++-----
 .../sortingcomponents/merging/lussac.py              | 12 +++++-------
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 5942cacdba..c9906b883d 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,8 +16,8 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "remove_emtpy" : True,
-        "recursive" : False,
+        "remove_emtpy": True,
+        "recursive": False,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
@@ -92,9 +92,7 @@ def run(self, extra_outputs=False):
 
         if self.recursive:
             while num_merges > 0:
-                self.analyzer = create_sorting_analyzer(sorting, 
-                                                        self.recording, 
-                                                        format="memory")
+                self.analyzer = create_sorting_analyzer(sorting, self.recording, format="memory")
                 self.analyzer.compute(["random_spikes", "templates"])
                 self.analyzer.compute("unit_locations", method="monopolar_triangulation")
                 self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 4112b40bae..7dae0cbc8c 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -238,8 +238,8 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "remove_emtpy" : True,
-        "recursive" : False,
+        "remove_emtpy": True,
+        "recursive": False,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
@@ -282,7 +282,7 @@ def __init__(self, recording, sorting, kwargs):
     def _get_new_sorting(self):
         lussac_kwargs = self.params.get("lussac_kwargs", None)
         merges = get_potential_auto_merge(self.analyzer, **lussac_kwargs, preset="lussac")
-                
+
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         merges = resolve_merging_graph(self.analyzer.sorting, merges)
@@ -290,16 +290,14 @@ def _get_new_sorting(self):
         return new_sorting, merges
 
     def run(self, extra_outputs=False):
-        
+
         sorting, merges = self._get_new_sorting()
         num_merges = len(merges)
         all_merges = [merges]
 
         if self.recursive:
             while num_merges > 0:
-                self.analyzer = create_sorting_analyzer(sorting, 
-                                                        self.recording, 
-                                                        format="memory")
+                self.analyzer = create_sorting_analyzer(sorting, self.recording, format="memory")
                 self.analyzer.compute(["random_spikes", "templates"])
                 self.analyzer.compute("unit_locations", method="monopolar_triangulation")
                 self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])

From 5c6edf850d763985a1ed04e045f06235ef30a4f9 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 24 Jun 2024 21:12:56 +0200
Subject: [PATCH 096/164] WIP

---
 src/spikeinterface/core/sorting_tools.py      | 97 +++++++++++++++++++
 src/spikeinterface/curation/auto_merge.py     |  2 +-
 .../sortingcomponents/merging/circus.py       |  8 +-
 .../sortingcomponents/merging/lussac.py       |  8 +-
 .../sortingcomponents/merging/tools.py        | 47 +--------
 5 files changed, 109 insertions(+), 53 deletions(-)

diff --git a/src/spikeinterface/core/sorting_tools.py b/src/spikeinterface/core/sorting_tools.py
index 2313e7d253..2dc103250a 100644
--- a/src/spikeinterface/core/sorting_tools.py
+++ b/src/spikeinterface/core/sorting_tools.py
@@ -209,3 +209,100 @@ def random_spikes_selection(
         raise ValueError(f"random_spikes_selection(): method must be 'all' or 'uniform'")
 
     return random_spikes_indices
+
+def get_ids_after_merging(sorting, units_to_merge, new_unit_ids=None):
+    merged_unit_ids = set(sorting.unit_ids)
+    for count in range(len(units_to_merge)):
+        assert len(units_to_merge[count]) > 1, "A merge should have at least two units"
+        for unit_id in units_to_merge[count]:
+            assert unit_id in sorting.unit_ids, "Merged ids should be in the sorting"
+        if new_unit_ids is None:
+            for unit_id in units_to_merge[count][1:]:
+                merged_unit_ids.discard(unit_id)
+        else:
+            for unit_id in units_to_merge[count]:
+                merged_unit_ids.discard(unit_id)
+            merged_unit_ids = merged_unit_ids.union([new_unit_ids[count]])
+    return np.array(list(merged_unit_ids))
+
+def apply_merges_to_sorting(sorting, units_to_merge, new_unit_ids=None, censor_ms=None):
+    """
+    Function to apply a resolved representation of the merges to a sorting object. If censor_ms is not None,
+    duplicated spikes violating the censor_ms refractory period are removed
+
+    Parameters
+    ----------
+    sorting: The Sorting object to apply merges
+    units_to_merge : list/tuple of lists/tuples
+        A list of lists for every merge group. Each element needs to have at least two elements (two units to merge),
+        but it can also have more (merge multiple units at once).
+    new_unit_ids : None or list
+        A new unit_ids for merged units. If given, it needs to have the same length as `units_to_merge`. If None,
+        merged units will have the first unit_id of every lists of merges
+    censor_ms: None or float
+        When applying the merges, should be discard consecutive spikes violating a given refractory per
+    
+    Returns
+    -------
+    sorting :  The new Sorting object
+        The newly create sorting with the merged units
+    kept_indices : A boolean mask, if censor_ms is not None, telling which spike from the original spike vector
+        has been kept, given the refractory period violations (None if censor_ms is None)
+    """
+    spikes = sorting.to_spike_vector().copy()
+
+    if censor_ms is None:
+        to_keep = None
+    else:
+        to_keep = np.ones(len(spikes), dtype=bool)
+
+    if new_unit_ids is not None:
+        assert len(new_unit_ids) == len(units_to_merge), "new_unit_ids should have the same len as units_to_merge"
+    else:
+        new_unit_ids = [i[0] for i in units_to_merge]
+
+    all_unit_ids = get_ids_after_merging(sorting, units_to_merge, new_unit_ids)
+
+    segment_slices = {}
+    for segment_index in range(sorting.get_num_segments()):
+        s0, s1 = np.searchsorted(spikes["segment_index"], [segment_index, segment_index + 1], side="left")
+        segment_slices[segment_index] = (s0, s1)
+
+    if censor_ms is not None:
+        rpv = int(sorting.sampling_frequency * censor_ms / 1000)
+
+    max_index = len(sorting.unit_ids)
+
+    for unit_id, to_be_merged in zip(new_unit_ids, units_to_merge):
+        mask = np.in1d(spikes["unit_index"], sorting.ids_to_indices(to_be_merged))
+        if unit_id in sorting.unit_ids:
+            spikes["unit_index"][mask] = sorting.id_to_index(unit_id)
+        else:
+            spikes["unit_index"][mask] = max_index
+            max_index += 1
+
+        if censor_ms is not None:
+            for segment_index in range(sorting.get_num_segments()):
+                s0, s1 = segment_slices[segment_index]
+                (indices,) = s0 + np.nonzero(mask[s0:s1])
+                to_keep[indices[1:]] = np.diff(spikes[indices]["sample_index"]) > rpv
+
+    from spikeinterface.core import NumpySorting
+
+    times_list = []
+    labels_list = []
+    for segment_index in range(sorting.get_num_segments()):
+        s0, s1 = segment_slices[segment_index]
+        if censor_ms is not None:
+            times_list += [spikes["sample_index"][s0:s1][to_keep[s0:s1]]]
+            labels = spikes["unit_index"][s0:s1][to_keep[s0:s1]]
+            labels_list += [labels]
+        else:
+            times_list += [spikes["sample_index"][s0:s1]]
+            labels = spikes["unit_index"][s0:s1]
+            labels_list += [labels]
+
+    sorting = NumpySorting.from_times_labels(times_list, labels_list, sorting.sampling_frequency)
+    sorting = sorting.rename_units(all_unit_ids)
+
+    return sorting, to_keep
diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 15f734441f..0070d8997d 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -182,7 +182,7 @@ def get_potential_auto_merge(
             ]
 
     n = unit_ids.size
-    pair_mask = np.ones((n, n), dtype="bool")
+    pair_mask = np.triu(np.arange(n)) > 0
     outs = dict()
 
     for step in steps:
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index c9906b883d..7099d37ff1 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -5,7 +5,8 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
+from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph
+from spikeinterface.core.sorting_tools import apply_merges_to_sorting
 
 
 class CircusMerging(BaseMergingEngine):
@@ -18,6 +19,7 @@ class CircusMerging(BaseMergingEngine):
         "verbose": True,
         "remove_emtpy": True,
         "recursive": False,
+        "censor_ms" : 3,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
@@ -81,8 +83,8 @@ def _get_new_sorting(self):
             merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
             if self.verbose:
                 print(f"{len(merges)} merges have been detected via additional temporal splits")
-        merges = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, merges)
+        units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
+        new_sorting, _ = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
         return new_sorting
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 7dae0cbc8c..13b75b6680 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -13,7 +13,8 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph, apply_merges_to_sorting
+from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph
+from spikeinterface.core.sorting_tools import apply_merges_to_sorting
 
 
 def binom_sf(x: int, n: float, p: float) -> float:
@@ -238,6 +239,7 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
+        "censor_ms" : 3,
         "remove_emtpy": True,
         "recursive": False,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
@@ -285,8 +287,8 @@ def _get_new_sorting(self):
 
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
-        merges = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, merges)
+        units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
+        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
         return new_sorting, merges
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
index d86191987d..28f65f76b7 100644
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -41,49 +41,4 @@ def resolve_merging_graph(sorting, potential_merges):
         if merges.sum() > 1:
             final_merges += [list(sorting.unit_ids[np.flatnonzero(merges)])]
 
-    return final_merges
-
-
-def apply_merges_to_sorting(sorting, merges, censor_ms=0.4):
-    """
-    Function to apply a resolved representation of the merges to a sorting object. If censor_ms is not None,
-    duplicated spikes violating the censor_ms refractory period are removed
-    """
-    spikes = sorting.to_spike_vector().copy()
-    to_keep = np.ones(len(spikes), dtype=bool)
-
-    segment_slices = {}
-    for segment_index in range(sorting.get_num_segments()):
-        s0, s1 = np.searchsorted(spikes["segment_index"], [segment_index, segment_index + 1], side="left")
-        segment_slices[segment_index] = (s0, s1)
-
-    if censor_ms is not None:
-        rpv = int(sorting.sampling_frequency * censor_ms / 1000)
-
-    for connected in merges:
-        mask = np.in1d(spikes["unit_index"], sorting.ids_to_indices(connected))
-        spikes["unit_index"][mask] = sorting.id_to_index(connected[0])
-
-        if censor_ms is not None:
-            for segment_index in range(sorting.get_num_segments()):
-                s0, s1 = segment_slices[segment_index]
-                (indices,) = s0 + np.nonzero(mask[s0:s1])
-                to_keep[indices[1:]] = np.logical_or(
-                    to_keep[indices[1:]], np.diff(spikes[indices]["sample_index"]) > rpv
-                )
-
-    times_list = []
-    labels_list = []
-    for segment_index in range(sorting.get_num_segments()):
-        s0, s1 = segment_slices[segment_index]
-        if censor_ms is not None:
-            times_list += [spikes["sample_index"][s0:s1][to_keep[s0:s1]]]
-            unit_indices = spikes["unit_index"][s0:s1][to_keep[s0:s1]]
-            labels_list += [sorting.unit_ids[unit_indices]]
-        else:
-            times_list += [spikes["sample_index"][s0:s1]]
-            unit_indices = spikes["unit_index"][s0:s1]
-            labels_list += [sorting.unit_ids[unit_indices]]
-
-    sorting = NumpySorting.from_times_labels(times_list, labels_list, sorting.sampling_frequency)
-    return sorting
+    return final_merges
\ No newline at end of file

From e0165b3391983c7ef3e2114f936430e91d905c48 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 24 Jun 2024 21:25:53 +0200
Subject: [PATCH 097/164] WIP

---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 13b75b6680..caecf038e3 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -288,7 +288,7 @@ def _get_new_sorting(self):
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
+        new_sorting, _ = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
         return new_sorting, merges
 
     def run(self, extra_outputs=False):

From 2427c2295211b6855efcea442ef50dca9a5cfaa2 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 24 Jun 2024 19:26:16 +0000
Subject: [PATCH 098/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/core/sorting_tools.py               | 4 +++-
 src/spikeinterface/sortingcomponents/merging/circus.py | 6 ++++--
 src/spikeinterface/sortingcomponents/merging/lussac.py | 6 ++++--
 src/spikeinterface/sortingcomponents/merging/tools.py  | 2 +-
 4 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/spikeinterface/core/sorting_tools.py b/src/spikeinterface/core/sorting_tools.py
index 2dc103250a..45f7bc2863 100644
--- a/src/spikeinterface/core/sorting_tools.py
+++ b/src/spikeinterface/core/sorting_tools.py
@@ -210,6 +210,7 @@ def random_spikes_selection(
 
     return random_spikes_indices
 
+
 def get_ids_after_merging(sorting, units_to_merge, new_unit_ids=None):
     merged_unit_ids = set(sorting.unit_ids)
     for count in range(len(units_to_merge)):
@@ -225,6 +226,7 @@ def get_ids_after_merging(sorting, units_to_merge, new_unit_ids=None):
             merged_unit_ids = merged_unit_ids.union([new_unit_ids[count]])
     return np.array(list(merged_unit_ids))
 
+
 def apply_merges_to_sorting(sorting, units_to_merge, new_unit_ids=None, censor_ms=None):
     """
     Function to apply a resolved representation of the merges to a sorting object. If censor_ms is not None,
@@ -241,7 +243,7 @@ def apply_merges_to_sorting(sorting, units_to_merge, new_unit_ids=None, censor_m
         merged units will have the first unit_id of every lists of merges
     censor_ms: None or float
         When applying the merges, should be discard consecutive spikes violating a given refractory per
-    
+
     Returns
     -------
     sorting :  The new Sorting object
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 7099d37ff1..b29ad5af65 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -19,7 +19,7 @@ class CircusMerging(BaseMergingEngine):
         "verbose": True,
         "remove_emtpy": True,
         "recursive": False,
-        "censor_ms" : 3,
+        "censor_ms": 3,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
@@ -84,7 +84,9 @@ def _get_new_sorting(self):
             if self.verbose:
                 print(f"{len(merges)} merges have been detected via additional temporal splits")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting, _ = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
+        new_sorting, _ = apply_merges_to_sorting(
+            self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
+        )
         return new_sorting
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index caecf038e3..147ec76f5f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -239,7 +239,7 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "templates": None,
         "verbose": True,
-        "censor_ms" : 3,
+        "censor_ms": 3,
         "remove_emtpy": True,
         "recursive": False,
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
@@ -288,7 +288,9 @@ def _get_new_sorting(self):
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting, _ = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
+        new_sorting, _ = apply_merges_to_sorting(
+            self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
+        )
         return new_sorting, merges
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
index 28f65f76b7..155e530f2a 100644
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ b/src/spikeinterface/sortingcomponents/merging/tools.py
@@ -41,4 +41,4 @@ def resolve_merging_graph(sorting, potential_merges):
         if merges.sum() > 1:
             final_merges += [list(sorting.unit_ids[np.flatnonzero(merges)])]
 
-    return final_merges
\ No newline at end of file
+    return final_merges

From 31ddfec137b24bbb0a9dd9be8971e12f813c865a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 24 Jun 2024 21:27:41 +0200
Subject: [PATCH 099/164] Typo

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 7099d37ff1..91f107ac23 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -85,7 +85,7 @@ def _get_new_sorting(self):
                 print(f"{len(merges)} merges have been detected via additional temporal splits")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
         new_sorting, _ = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params['censor_ms'])
-        return new_sorting
+        return new_sorting, merges
 
     def run(self, extra_outputs=False):
         sorting, merges = self._get_new_sorting()

From 2df7ad32dacd128edc8fa7318b1e23db7218389e Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 24 Jun 2024 21:41:45 +0200
Subject: [PATCH 100/164] Refactoring

---
 src/spikeinterface/curation/curation_tools.py | 41 +++++++++++++++++
 .../sortingcomponents/merging/circus.py       |  4 +-
 .../sortingcomponents/merging/lussac.py       |  4 +-
 .../sortingcomponents/merging/tools.py        | 44 -------------------
 4 files changed, 45 insertions(+), 48 deletions(-)
 delete mode 100644 src/spikeinterface/sortingcomponents/merging/tools.py

diff --git a/src/spikeinterface/curation/curation_tools.py b/src/spikeinterface/curation/curation_tools.py
index ee42a3b306..16321b3e0b 100644
--- a/src/spikeinterface/curation/curation_tools.py
+++ b/src/spikeinterface/curation/curation_tools.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 from typing import Optional
 import numpy as np
+from spikeinterface import SortingAnalyzer
 
 
 try:
@@ -133,3 +134,43 @@ def find_duplicated_spikes(
         return _find_duplicated_spikes_keep_last_iterative(spike_train.astype(np.int64), censored_period)
     else:
         raise ValueError(f"Method '{method}' isn't a valid method for find_duplicated_spikes. Use one of {_methods}")
+
+def remove_empty_units(sorting_or_sorting_analyzer, minimum_spikes=10):
+    if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
+        sorting = sorting_or_sorting_analyzer.sorting
+        counts = sorting.get_total_num_spikes()
+        ids_to_select = []
+        for id, num_spikes in counts.items():
+            if num_spikes >= minimum_spikes:
+                ids_to_select += [id]
+        return sorting_or_sorting_analyzer.select_units(ids_to_select)
+    else:
+        counts = sorting_or_sorting_analyzer.get_total_num_spikes()
+        ids_to_select = []
+        for id, num_spikes in counts.items():
+            if num_spikes >= minimum_spikes:
+                ids_to_select += [id]
+        return sorting_or_sorting_analyzer.select_units(ids_to_select)
+
+
+def resolve_merging_graph(sorting, potential_merges):
+    """
+    Function to provide, given a list of potential_merges, a resolved merging
+    graph based on the connected components.
+    """
+    from scipy.sparse.csgraph import connected_components
+    from scipy.sparse import lil_matrix
+
+    n = len(sorting.unit_ids)
+    graph = lil_matrix((n, n))
+    for i, j in potential_merges:
+        graph[sorting.id_to_index(i), sorting.id_to_index(j)] = 1
+
+    n_components, labels = connected_components(graph, directed=True, connection="weak", return_labels=True)
+    final_merges = []
+    for i in range(n_components):
+        merges = labels == i
+        if merges.sum() > 1:
+            final_merges += [list(sorting.unit_ids[np.flatnonzero(merges)])]
+
+    return final_merges
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 78fb33cafa..a167597d47 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -5,7 +5,7 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph
+from spikeinterface.curation.curation_tools import resolve_merging_graph
 from spikeinterface.core.sorting_tools import apply_merges_to_sorting
 
 
@@ -64,7 +64,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
         if self.remove_empty:
-            from .tools import remove_empty_units
+            from spikeinterface.curation.curation_tools import remove_empty_units
 
             self.analyzer = remove_empty_units(self.analyzer)
 
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 147ec76f5f..ccd84acb62 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -13,7 +13,7 @@
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.sortingcomponents.merging.tools import resolve_merging_graph
+from spikeinterface.curation.curation_tools import resolve_merging_graph
 from spikeinterface.core.sorting_tools import apply_merges_to_sorting
 
 
@@ -275,7 +275,7 @@ def __init__(self, recording, sorting, kwargs):
             self.analyzer.compute("unit_locations", method="monopolar_triangulation")
 
         if self.remove_empty:
-            from .tools import remove_empty_units
+            from spikeinterface.curation.curation_tools import remove_empty_units
 
             self.analyzer = remove_empty_units(self.analyzer)
 
diff --git a/src/spikeinterface/sortingcomponents/merging/tools.py b/src/spikeinterface/sortingcomponents/merging/tools.py
deleted file mode 100644
index 155e530f2a..0000000000
--- a/src/spikeinterface/sortingcomponents/merging/tools.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import numpy as np
-from spikeinterface.core import NumpySorting
-from spikeinterface import SortingAnalyzer
-
-
-def remove_empty_units(sorting_or_sorting_analyzer, minimum_spikes=10):
-    if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
-        sorting = sorting_or_sorting_analyzer.sorting
-        counts = sorting.get_total_num_spikes()
-        ids_to_select = []
-        for id, num_spikes in counts.items():
-            if num_spikes >= minimum_spikes:
-                ids_to_select += [id]
-        return sorting_or_sorting_analyzer.select_units(ids_to_select)
-    else:
-        counts = sorting_or_sorting_analyzer.get_total_num_spikes()
-        ids_to_select = []
-        for id, num_spikes in counts.items():
-            if num_spikes >= minimum_spikes:
-                ids_to_select += [id]
-        return sorting_or_sorting_analyzer.select_units(ids_to_select)
-
-
-def resolve_merging_graph(sorting, potential_merges):
-    """
-    Function to provide, given a list of potential_merges, a resolved merging
-    graph based on the connected components.
-    """
-    from scipy.sparse.csgraph import connected_components
-    from scipy.sparse import lil_matrix
-
-    n = len(sorting.unit_ids)
-    graph = lil_matrix((n, n))
-    for i, j in potential_merges:
-        graph[sorting.id_to_index(i), sorting.id_to_index(j)] = 1
-
-    n_components, labels = connected_components(graph, directed=True, connection="weak", return_labels=True)
-    final_merges = []
-    for i in range(n_components):
-        merges = labels == i
-        if merges.sum() > 1:
-            final_merges += [list(sorting.unit_ids[np.flatnonzero(merges)])]
-
-    return final_merges

From 30f361758782486e66ff5960dafbf82240ae5a02 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 24 Jun 2024 19:42:10 +0000
Subject: [PATCH 101/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/curation_tools.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/spikeinterface/curation/curation_tools.py b/src/spikeinterface/curation/curation_tools.py
index 16321b3e0b..fb76f5b434 100644
--- a/src/spikeinterface/curation/curation_tools.py
+++ b/src/spikeinterface/curation/curation_tools.py
@@ -135,6 +135,7 @@ def find_duplicated_spikes(
     else:
         raise ValueError(f"Method '{method}' isn't a valid method for find_duplicated_spikes. Use one of {_methods}")
 
+
 def remove_empty_units(sorting_or_sorting_analyzer, minimum_spikes=10):
     if isinstance(sorting_or_sorting_analyzer, SortingAnalyzer):
         sorting = sorting_or_sorting_analyzer.sorting

From 10fce9dd984b6e842d2fc5c612c1b0d8544c136a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 27 Jun 2024 13:12:26 +0200
Subject: [PATCH 102/164] Larger params

---
 .../sortingcomponents/merging/circus.py              | 12 ++++--------
 .../sortingcomponents/merging/lussac.py              |  4 ++--
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index a167597d47..26ab29ca59 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -24,19 +24,15 @@ class CircusMerging(BaseMergingEngine):
         "curation_kwargs": {
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
-            "maximum_distance_um": 20,
+            "maximum_distance_um": 50,
             "presence_distance_thresh": 100,
-            "template_diff_thresh": 0.3,
-            "bin_ms": 1,
-            "window_ms": 250,
+            "template_diff_thresh": 0.5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um": 20,
+            "maximum_distance_um": 50,
             "presence_distance_thresh": 100,
-            "template_diff_thresh": 0.3,
-            "bin_ms": 1,
-            "window_ms": 250,
+            "template_diff_thresh": 0.5,
         },
     }
 
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index ccd84acb62..393c6d4cc1 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -245,9 +245,9 @@ class LussacMerging(BaseMergingEngine):
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "lussac_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um": 20,
+            "maximum_distance_um": 50,
             "refractory_period": (0.3, 1.0),
-            "template_diff_thresh": 0.3,
+            "template_diff_thresh": 0.5,
         },
     }
 

From 816f2fde4b9f4cba4175e58efd9912ed65f060f7 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 27 Jun 2024 13:22:02 +0200
Subject: [PATCH 103/164] WIP

---
 src/spikeinterface/curation/auto_merge.py              | 4 ++--
 src/spikeinterface/sortingcomponents/merging/circus.py | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 0070d8997d..fee443c56b 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -157,8 +157,8 @@ def get_potential_auto_merge(
                 "min_spikes",
                 "remove_contaminated",
                 "unit_positions",
-                "correlogram",
                 "template_similarity",
+                "correlogram",
                 "check_increase_score",
             ]
         elif preset == "temporal_splits":
@@ -166,8 +166,8 @@ def get_potential_auto_merge(
                 "min_spikes",
                 "remove_contaminated",
                 "unit_positions",
-                "correlogram",
                 "template_similarity",
+                "correlogram",
                 "presence_distance",
                 "check_increase_score",
             ]
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 26ab29ca59..3f9f773ada 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -76,9 +76,10 @@ def _get_new_sorting(self):
             print(f"{len(merges)} merges have been detected via auto merges")
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
-            merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
+            more_merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
             if self.verbose:
-                print(f"{len(merges)} merges have been detected via additional temporal splits")
+                print(f"{len(more_merges)} merges have been detected via additional temporal splits")
+            merges += more_merges
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
         new_sorting, _ = apply_merges_to_sorting(
             self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]

From e437670923b52bdf1cf247d16c13aa892f40c688 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 27 Jun 2024 16:23:53 +0200
Subject: [PATCH 104/164] Bug

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 3f9f773ada..8ee64276d4 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -76,7 +76,7 @@ def _get_new_sorting(self):
             print(f"{len(merges)} merges have been detected via auto merges")
         temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
         if temporal_splits_kwargs is not None:
-            more_merges += get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
+            more_merges = get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
             if self.verbose:
                 print(f"{len(more_merges)} merges have been detected via additional temporal splits")
             merges += more_merges

From 750eba0c4557cb1bb73ad2da3b9f1fb9cf8ea2e6 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Fri, 28 Jun 2024 09:53:09 +0200
Subject: [PATCH 105/164] Adding Knn merging

---
 src/spikeinterface/curation/auto_merge.py     |  48 +++++++++
 .../sortingcomponents/merging/knn.py          | 101 ++++++++++++++++++
 .../sortingcomponents/merging/method_list.py  |   3 +-
 3 files changed, 151 insertions(+), 1 deletion(-)
 create mode 100644 src/spikeinterface/sortingcomponents/merging/knn.py

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index fee443c56b..ba7edbecd5 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -37,6 +37,7 @@ def get_potential_auto_merge(
     template_metric="l1",
     p_value=0.2,
     CC_threshold=0.1,
+    k_nn=5,
     **presence_distance_kwargs,
 ):
     """
@@ -147,6 +148,7 @@ def get_potential_auto_merge(
         "correlogram",
         "template_similarity",
         "presence_distance",
+        "knn",
         "cross_contamination",
         "check_increase_score",
     ]
@@ -180,6 +182,15 @@ def get_potential_auto_merge(
                 "cross_contamination",
                 "check_increase_score",
             ]
+        elif preset == "knn":
+            steps = [
+                "min_spikes",
+                "remove_contaminated",
+                "unit_positions",
+                "knn",
+                "correlogram",
+                "check_increase_score",
+            ]
 
     n = unit_ids.size
     pair_mask = np.triu(np.arange(n)) > 0
@@ -282,6 +293,9 @@ def get_potential_auto_merge(
             pair_mask = pair_mask & (templates_diff < template_diff_thresh)
             outs["templates_diff"] = templates_diff
 
+        elif step == "knn" in steps:
+            pair_mask = get_pairs_via_nntree(sorting_analyzer, k_nn, pair_mask)
+
         # STEP 6 : [optional] check how the rates overlap in times
         elif step == "presence_distance" in steps:
             presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
@@ -317,6 +331,40 @@ def get_potential_auto_merge(
         return potential_merges
 
 
+def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
+
+    sorting = sorting_analyzer.sorting
+    unit_ids = sorting.unit_ids
+    n = len(unit_ids)
+
+    if pair_mask is None:
+        pair_mask = np.ones((n, n), dtype="bool")
+
+    unit_positions = sorting_analyzer.get_extension('unit_locations').get_data()
+    spike_positions = sorting_analyzer.get_extension('spike_locations').get_data()
+    spike_amplitudes = sorting_analyzer.get_extension('spike_amplitudes').get_data()
+    spikes = sorting_analyzer.sorting.to_spike_vector()
+    data = np.vstack((spike_amplitudes, spike_positions['x'], spike_positions['y'])).T
+    from sklearn.neighbors import NearestNeighbors
+    data = (data - data.mean(0))/data.std(0)
+
+    all_spike_counts = sorting_analyzer.sorting.count_num_spikes_per_unit()
+    all_spike_counts = np.array(list(all_spike_counts.keys()))
+    
+    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1)
+    kdtree.fit(data)
+    for unit_ind in range(n):
+        print(unit_ind)
+        mask = spikes['unit_index'] == unit_ind
+        ind = kdtree.kneighbors(data[mask], return_distance=False)
+        ind = ind.flatten()
+        chan_inds, all_counts = np.unique(spikes['unit_index'][ind], return_counts=True)
+        all_counts = all_counts.astype(float)
+        all_counts /= all_spike_counts[chan_inds]
+        best_indices = np.argsort(all_counts)[::-1][1:]
+        pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
+    return pair_mask
+
 def compute_correlogram_diff(sorting, correlograms_smoothed, win_sizes, pair_mask=None):
     """
     Original author: Aurelien Wyngaard (lussac)
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
new file mode 100644
index 0000000000..33abd7defa
--- /dev/null
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+import numpy as np
+import math
+
+try:
+    import numba
+
+    HAVE_NUMBA = True
+except ImportError:
+    HAVE_NUMBA = False
+
+from .main import BaseMergingEngine
+from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
+from spikeinterface.core.analyzer_extension_core import ComputeTemplates
+from spikeinterface.curation.auto_merge import get_potential_auto_merge
+from spikeinterface.curation.curation_tools import resolve_merging_graph
+from spikeinterface.core.sorting_tools import apply_merges_to_sorting
+
+
+class KNNMerging(BaseMergingEngine):
+    """
+    Meta merging inspired from the Lussac metric
+    """
+
+    default_params = {
+        "templates": None,
+        "verbose": True,
+        "censor_ms": 3,
+        "remove_emtpy": True,
+        "recursive": True,   
+        "knn_kwargs" : {"minimum_spikes": 50,
+                        "maximum_distance_um": 50,
+                        "refractory_period": (0.3, 1.0),
+                        "corr_diff_thresh": 0.5}
+    }
+
+    def __init__(self, recording, sorting, kwargs):
+        self.params = self.default_params.copy()
+        self.params.update(**kwargs)
+        self.sorting = sorting
+        self.verbose = self.params.pop("verbose")
+        self.remove_empty = self.params.get("remove_empty", True)
+        self.recording = recording
+        self.templates = self.params.pop("templates", None)
+        self.recursive = self.params.pop("recursive", True)
+
+        if self.templates is not None:
+            sparsity = self.templates.sparsity
+            templates_array = self.templates.get_dense_templates().copy()
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
+            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
+            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
+            self.analyzer.extensions["templates"].data["average"] = templates_array
+            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+            self.analyzer.compute("spike_locations", "grid_convolution")
+            self.analyzer.compute("spike_amplitudes")
+        else:
+            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
+            self.analyzer.compute(["random_spikes", "templates"])
+            self.analyzer.compute("spike_locations", "grid_convolution")
+            self.analyzer.compute("spike_amplitudes")
+
+        if self.remove_empty:
+            from spikeinterface.curation.curation_tools import remove_empty_units
+
+            self.analyzer = remove_empty_units(self.analyzer)
+
+
+    def _get_new_sorting(self):
+        knn_kwargs = self.params.get("knn_kwargs", None)
+        merges = get_potential_auto_merge(self.analyzer, **knn_kwargs, preset="knn")
+
+        if self.verbose:
+            print(f"{len(merges)} merges have been detected")
+        units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
+        new_sorting, _ = apply_merges_to_sorting(
+            self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
+        )
+        return new_sorting, merges
+
+    def run(self, extra_outputs=False):
+
+        sorting, merges = self._get_new_sorting()
+        num_merges = len(merges)
+        all_merges = [merges]
+
+        if self.recursive:
+            while num_merges > 0:
+                self.analyzer = create_sorting_analyzer(sorting, self.recording, format="memory")
+                self.analyzer.compute(["random_spikes", "templates"])
+                self.analyzer.compute("spike_locations", "grid_convolution")
+                self.analyzer.compute("spike_amplitudes")
+                self.analyzer.compute("unit_locations", method="monopolar_triangulation")
+                sorting, merges = self._get_new_sorting()
+                num_merges = len(merges)
+                all_merges += [merges]
+
+        if extra_outputs:
+            return sorting, all_merges
+        else:
+            return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index db1bb116e3..5341e23448 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 from .circus import CircusMerging
 from .lussac import LussacMerging
+from .knn import KNNMerging
 
-merging_methods = {"circus": CircusMerging, "lussac": LussacMerging}
+merging_methods = {"circus": CircusMerging, "lussac": LussacMerging, "knn" : KNNMerging}

From 3058a2fe6cf337aa93c801ef5a270859d00b79ac Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Fri, 28 Jun 2024 10:52:26 +0200
Subject: [PATCH 106/164] WIP

---
 src/spikeinterface/curation/auto_merge.py | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index ba7edbecd5..b6c7614c5a 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -340,21 +340,35 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
     if pair_mask is None:
         pair_mask = np.ones((n, n), dtype="bool")
 
-    unit_positions = sorting_analyzer.get_extension('unit_locations').get_data()
     spike_positions = sorting_analyzer.get_extension('spike_locations').get_data()
     spike_amplitudes = sorting_analyzer.get_extension('spike_amplitudes').get_data()
     spikes = sorting_analyzer.sorting.to_spike_vector()
+
+    ## We need to build a sparse distance matrix
     data = np.vstack((spike_amplitudes, spike_positions['x'], spike_positions['y'])).T
     from sklearn.neighbors import NearestNeighbors
     data = (data - data.mean(0))/data.std(0)
 
+    import scipy.sparse
+    import sklearn.metrics
+    distances = scipy.sparse.lil_matrix((len(data), len(data)), dtype=np.float32)
+    for unit_ind1 in range(n):
+        mask_1 = spikes['unit_index'] == unit_ind1
+        print(unit_ind1)
+        for unit_ind2 in range(unit_ind1+1, n):
+            mask_2 = spikes['unit_index'] == unit_ind2
+            if not pair_mask[unit_ind1, unit_ind2]:
+                continue
+
+            tmp = sklearn.metrics.pairwise_distances(data[mask_1], data[mask_2])
+            distances[mask_1][:, mask_2] = tmp
+
     all_spike_counts = sorting_analyzer.sorting.count_num_spikes_per_unit()
     all_spike_counts = np.array(list(all_spike_counts.keys()))
     
-    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1)
-    kdtree.fit(data)
+    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1, metric='precomputed')
+    kdtree.fit(distances)
     for unit_ind in range(n):
-        print(unit_ind)
         mask = spikes['unit_index'] == unit_ind
         ind = kdtree.kneighbors(data[mask], return_distance=False)
         ind = ind.flatten()

From c73e8603778441cd9305dcabe9945ff74210f115 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 28 Jun 2024 08:55:54 +0000
Subject: [PATCH 107/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py     | 25 +++++++++++--------
 .../sortingcomponents/merging/knn.py          | 13 +++++-----
 .../sortingcomponents/merging/method_list.py  |  2 +-
 3 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index b6c7614c5a..80e027c394 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -340,23 +340,25 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
     if pair_mask is None:
         pair_mask = np.ones((n, n), dtype="bool")
 
-    spike_positions = sorting_analyzer.get_extension('spike_locations').get_data()
-    spike_amplitudes = sorting_analyzer.get_extension('spike_amplitudes').get_data()
+    spike_positions = sorting_analyzer.get_extension("spike_locations").get_data()
+    spike_amplitudes = sorting_analyzer.get_extension("spike_amplitudes").get_data()
     spikes = sorting_analyzer.sorting.to_spike_vector()
 
     ## We need to build a sparse distance matrix
-    data = np.vstack((spike_amplitudes, spike_positions['x'], spike_positions['y'])).T
+    data = np.vstack((spike_amplitudes, spike_positions["x"], spike_positions["y"])).T
     from sklearn.neighbors import NearestNeighbors
-    data = (data - data.mean(0))/data.std(0)
+
+    data = (data - data.mean(0)) / data.std(0)
 
     import scipy.sparse
     import sklearn.metrics
+
     distances = scipy.sparse.lil_matrix((len(data), len(data)), dtype=np.float32)
     for unit_ind1 in range(n):
-        mask_1 = spikes['unit_index'] == unit_ind1
+        mask_1 = spikes["unit_index"] == unit_ind1
         print(unit_ind1)
-        for unit_ind2 in range(unit_ind1+1, n):
-            mask_2 = spikes['unit_index'] == unit_ind2
+        for unit_ind2 in range(unit_ind1 + 1, n):
+            mask_2 = spikes["unit_index"] == unit_ind2
             if not pair_mask[unit_ind1, unit_ind2]:
                 continue
 
@@ -365,20 +367,21 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
 
     all_spike_counts = sorting_analyzer.sorting.count_num_spikes_per_unit()
     all_spike_counts = np.array(list(all_spike_counts.keys()))
-    
-    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1, metric='precomputed')
+
+    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1, metric="precomputed")
     kdtree.fit(distances)
     for unit_ind in range(n):
-        mask = spikes['unit_index'] == unit_ind
+        mask = spikes["unit_index"] == unit_ind
         ind = kdtree.kneighbors(data[mask], return_distance=False)
         ind = ind.flatten()
-        chan_inds, all_counts = np.unique(spikes['unit_index'][ind], return_counts=True)
+        chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
         all_counts = all_counts.astype(float)
         all_counts /= all_spike_counts[chan_inds]
         best_indices = np.argsort(all_counts)[::-1][1:]
         pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
     return pair_mask
 
+
 def compute_correlogram_diff(sorting, correlograms_smoothed, win_sizes, pair_mask=None):
     """
     Original author: Aurelien Wyngaard (lussac)
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index 33abd7defa..2ffdf345a2 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -27,11 +27,13 @@ class KNNMerging(BaseMergingEngine):
         "verbose": True,
         "censor_ms": 3,
         "remove_emtpy": True,
-        "recursive": True,   
-        "knn_kwargs" : {"minimum_spikes": 50,
-                        "maximum_distance_um": 50,
-                        "refractory_period": (0.3, 1.0),
-                        "corr_diff_thresh": 0.5}
+        "recursive": True,
+        "knn_kwargs": {
+            "minimum_spikes": 50,
+            "maximum_distance_um": 50,
+            "refractory_period": (0.3, 1.0),
+            "corr_diff_thresh": 0.5,
+        },
     }
 
     def __init__(self, recording, sorting, kwargs):
@@ -65,7 +67,6 @@ def __init__(self, recording, sorting, kwargs):
 
             self.analyzer = remove_empty_units(self.analyzer)
 
-
     def _get_new_sorting(self):
         knn_kwargs = self.params.get("knn_kwargs", None)
         merges = get_potential_auto_merge(self.analyzer, **knn_kwargs, preset="knn")
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index 5341e23448..fb348f9faa 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -3,4 +3,4 @@
 from .lussac import LussacMerging
 from .knn import KNNMerging
 
-merging_methods = {"circus": CircusMerging, "lussac": LussacMerging, "knn" : KNNMerging}
+merging_methods = {"circus": CircusMerging, "lussac": LussacMerging, "knn": KNNMerging}

From 55460a904f687defaea4a14263f57b75932cdcfa Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 28 Jun 2024 15:58:52 +0200
Subject: [PATCH 108/164] WIP

---
 src/spikeinterface/curation/auto_merge.py | 38 +++++++++++++----------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 80e027c394..41577da610 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -331,7 +331,7 @@ def get_potential_auto_merge(
         return potential_merges
 
 
-def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
+def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, sparse_distances=False):
 
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids
@@ -350,33 +350,39 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
 
     data = (data - data.mean(0)) / data.std(0)
 
-    import scipy.sparse
-    import sklearn.metrics
+    if sparse_distances:
+        import scipy.sparse
+        import sklearn.metrics
 
-    distances = scipy.sparse.lil_matrix((len(data), len(data)), dtype=np.float32)
-    for unit_ind1 in range(n):
-        mask_1 = spikes["unit_index"] == unit_ind1
-        print(unit_ind1)
-        for unit_ind2 in range(unit_ind1 + 1, n):
-            mask_2 = spikes["unit_index"] == unit_ind2
-            if not pair_mask[unit_ind1, unit_ind2]:
-                continue
+        distances = scipy.sparse.lil_matrix((len(data), len(data)), dtype=np.float32)
 
-            tmp = sklearn.metrics.pairwise_distances(data[mask_1], data[mask_2])
-            distances[mask_1][:, mask_2] = tmp
+        for unit_ind1 in range(2):
+            valid = pair_mask[unit_ind1, unit_ind1+1:]
+            valid_indices = np.arange(unit_ind1+1, n)[valid]
+            mask_2 = np.isin(spikes["unit_index"], valid_indices)
+            if np.sum(mask_2) > 0:
+                mask_1 = spikes["unit_index"] == unit_ind1
+                tmp = sklearn.metrics.pairwise_distances(data[mask_1], data[mask_2])
+                distances[mask_1][:, mask_2] = tmp
 
     all_spike_counts = sorting_analyzer.sorting.count_num_spikes_per_unit()
     all_spike_counts = np.array(list(all_spike_counts.keys()))
 
-    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1, metric="precomputed")
-    kdtree.fit(distances)
+    if sparse_distances:
+        kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1, metric="precomputed")
+        kdtree.fit(distances)
+    else:
+        kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1)
+        kdtree.fit(data)
+
     for unit_ind in range(n):
+        print(unit_ind)
         mask = spikes["unit_index"] == unit_ind
         ind = kdtree.kneighbors(data[mask], return_distance=False)
         ind = ind.flatten()
         chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
         all_counts = all_counts.astype(float)
-        all_counts /= all_spike_counts[chan_inds]
+        #all_counts /= all_spike_counts[chan_inds]
         best_indices = np.argsort(all_counts)[::-1][1:]
         pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
     return pair_mask

From c3e2115e4065afb90bdca0bf3b1109c9f6f9c0a4 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Sat, 29 Jun 2024 07:15:25 +0200
Subject: [PATCH 109/164] knn

---
 src/spikeinterface/curation/auto_merge.py | 46 ++++++++---------------
 1 file changed, 15 insertions(+), 31 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 41577da610..83705b94db 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -331,7 +331,7 @@ def get_potential_auto_merge(
         return potential_merges
 
 
-def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, sparse_distances=False):
+def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
 
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids
@@ -349,42 +349,26 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, sparse_distan
     from sklearn.neighbors import NearestNeighbors
 
     data = (data - data.mean(0)) / data.std(0)
-
-    if sparse_distances:
-        import scipy.sparse
-        import sklearn.metrics
-
-        distances = scipy.sparse.lil_matrix((len(data), len(data)), dtype=np.float32)
-
-        for unit_ind1 in range(2):
-            valid = pair_mask[unit_ind1, unit_ind1+1:]
-            valid_indices = np.arange(unit_ind1+1, n)[valid]
-            mask_2 = np.isin(spikes["unit_index"], valid_indices)
-            if np.sum(mask_2) > 0:
-                mask_1 = spikes["unit_index"] == unit_ind1
-                tmp = sklearn.metrics.pairwise_distances(data[mask_1], data[mask_2])
-                distances[mask_1][:, mask_2] = tmp
-
     all_spike_counts = sorting_analyzer.sorting.count_num_spikes_per_unit()
     all_spike_counts = np.array(list(all_spike_counts.keys()))
 
-    if sparse_distances:
-        kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1, metric="precomputed")
-        kdtree.fit(distances)
-    else:
-        kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1)
-        kdtree.fit(data)
+    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1)
+    kdtree.fit(data)
 
     for unit_ind in range(n):
-        print(unit_ind)
         mask = spikes["unit_index"] == unit_ind
-        ind = kdtree.kneighbors(data[mask], return_distance=False)
-        ind = ind.flatten()
-        chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
-        all_counts = all_counts.astype(float)
-        #all_counts /= all_spike_counts[chan_inds]
-        best_indices = np.argsort(all_counts)[::-1][1:]
-        pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
+        valid = pair_mask[unit_ind, unit_ind+1:]
+        valid_indices = np.arange(unit_ind+1, n)[valid]
+        if len(valid_indices) > 0:
+            ind = kdtree.kneighbors(data[mask], return_distance=False)
+            ind = ind.flatten()
+            mask_2 = np.isin(spikes["unit_index"][ind], valid_indices)
+            ind = ind[mask_2]
+            chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
+            all_counts = all_counts.astype(float)
+            #all_counts /= all_spike_counts[chan_inds]
+            best_indices = np.argsort(all_counts)[::-1][0:]
+            pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
     return pair_mask
 
 

From f609b23aba6849d90effccf9d08584aedf303c63 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 29 Jun 2024 05:15:48 +0000
Subject: [PATCH 110/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 83705b94db..f2597d162f 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -357,8 +357,8 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
 
     for unit_ind in range(n):
         mask = spikes["unit_index"] == unit_ind
-        valid = pair_mask[unit_ind, unit_ind+1:]
-        valid_indices = np.arange(unit_ind+1, n)[valid]
+        valid = pair_mask[unit_ind, unit_ind + 1 :]
+        valid_indices = np.arange(unit_ind + 1, n)[valid]
         if len(valid_indices) > 0:
             ind = kdtree.kneighbors(data[mask], return_distance=False)
             ind = ind.flatten()
@@ -366,7 +366,7 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
             ind = ind[mask_2]
             chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
             all_counts = all_counts.astype(float)
-            #all_counts /= all_spike_counts[chan_inds]
+            # all_counts /= all_spike_counts[chan_inds]
             best_indices = np.argsort(all_counts)[::-1][0:]
             pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
     return pair_mask

From a67b4d3eff5df4d0482fa1366fb508288c9cd1cd Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 1 Jul 2024 15:40:57 +0200
Subject: [PATCH 111/164] WIP

---
 src/spikeinterface/preprocessing/motion.py          | 1 -
 src/spikeinterface/sortingcomponents/merging/knn.py | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/spikeinterface/preprocessing/motion.py b/src/spikeinterface/preprocessing/motion.py
index 0d65b1936a..6f895d06d6 100644
--- a/src/spikeinterface/preprocessing/motion.py
+++ b/src/spikeinterface/preprocessing/motion.py
@@ -206,7 +206,6 @@ def correct_motion(
     preset="nonrigid_accurate",
     folder=None,
     output_motion_info=False,
-    overwrite=False,
     detect_kwargs={},
     select_kwargs={},
     localize_peaks_kwargs={},
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index 5ac91d5102..cc56d1c7b7 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -32,7 +32,7 @@ class KNNMerging(BaseMergingEngine):
             "minimum_spikes": 50,
             "maximum_distance_um": 100,
             "refractory_period": (0.3, 1.0),
-            "corr_diff_thresh": 0.25,
+            "corr_diff_thresh": 0.2,
             "k_nn" : 10
         },
     }

From 016d7cc48e0c79a0c1e59137fff06c7b76d05273 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 2 Jul 2024 14:59:53 +0200
Subject: [PATCH 112/164] Fixes

---
 src/spikeinterface/curation/auto_merge.py     | 28 +++++++++++--------
 .../sortingcomponents/merging/knn.py          |  2 +-
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index ad359a3e7e..245c828b9e 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -38,6 +38,7 @@ def get_potential_auto_merge(
     p_value=0.2,
     CC_threshold=0.1,
     k_nn=10,
+    knn_kwargs=None,
     **presence_distance_kwargs,
 ):
     """
@@ -111,6 +112,8 @@ def get_potential_auto_merge(
         Parameter to control how present two units should be simultaneously
     k_nn : int, default 5
         The number of neighbors to consider for every spike in the recording
+    knn_kwargs : dict, default None
+        The dict of extra params to be passed to knn
     extra_outputs : bool, default: False
         If True, an additional dictionary (`outs`) with processed data is returned
     steps : None or list of str, default: None
@@ -202,14 +205,14 @@ def get_potential_auto_merge(
 
         assert step in all_steps, f"{step} is not a valid step"
 
-        # STEP 1 :
+        # STEP : remove units with too few spikes
         if step == "min_spikes":
             num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
             to_remove = num_spikes < minimum_spikes
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
 
-        # STEP 2 : remove contaminated auto corr
+        # STEP : remove contaminated auto corr
         elif step == "remove_contaminated":
             contaminations, nb_violations = compute_refrac_period_violations(
                 sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
@@ -220,7 +223,7 @@ def get_potential_auto_merge(
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
 
-        # STEP 3 : unit positions are estimated roughly with channel
+        # STEP : unit positions are estimated roughly with channel
         elif step == "unit_positions" in steps:
             positions_ext = sorting_analyzer.get_extension("unit_locations")
             if positions_ext is not None:
@@ -237,7 +240,7 @@ def get_potential_auto_merge(
             pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
             outs["unit_distances"] = unit_distances
 
-        # STEP 4 : potential auto merge by correlogram
+        # STEP : potential auto merge by correlogram
         elif step == "correlogram" in steps:
             correlograms_ext = sorting_analyzer.get_extension("correlograms")
             if correlograms_ext is not None:
@@ -268,7 +271,7 @@ def get_potential_auto_merge(
             outs["correlogram_diff"] = correlogram_diff
             outs["win_sizes"] = win_sizes
 
-        # STEP 5 : check if potential merge with CC also have template similarity
+        # STEP : check if potential merge with CC also have template similarity
         elif step == "template_similarity" in steps:
             template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
             if template_similarity_ext is not None:
@@ -295,23 +298,26 @@ def get_potential_auto_merge(
             pair_mask = pair_mask & (templates_diff < template_diff_thresh)
             outs["templates_diff"] = templates_diff
 
+        # STEP : check the vicinity of the spikes
         elif step == "knn" in steps:
-            pair_mask = get_pairs_via_nntree(sorting_analyzer, k_nn, pair_mask)
+            if knn_kwargs is None:
+                knn_kwargs = dict()
+            pair_mask = get_pairs_via_nntree(sorting_analyzer, k_nn, pair_mask, **knn_kwargs)
 
-        # STEP 6 : [optional] check how the rates overlap in times
+        # STEP : check how the rates overlap in times
         elif step == "presence_distance" in steps:
             presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
             pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
             outs["presence_distances"] = presence_distances
 
-        # STEP 7 : [optional] check if the cross contamination is significant
+        # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
             refractory = (censored_period_ms, refractory_period_ms)
             CC, p_values = compute_cross_contaminations(sorting_analyzer, pair_mask, CC_threshold, refractory)
             pair_mask = pair_mask & (p_values > p_value)
             outs["cross_contaminations"] = CC, p_values
 
-        # STEP 8 : validate the potential merges with CC increase the contamination quality metrics
+        # STEP : validate the potential merges with CC increase the contamination quality metrics
         elif step == "check_increase_score" in steps:
             pair_mask, pairs_decreased_score = check_improve_contaminations_score(
                 sorting_analyzer,
@@ -333,7 +339,7 @@ def get_potential_auto_merge(
         return potential_merges
 
 
-def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
+def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
 
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids
@@ -354,7 +360,7 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None):
     all_spike_counts = sorting_analyzer.sorting.count_num_spikes_per_unit()
     all_spike_counts = np.array(list(all_spike_counts.keys()))
 
-    kdtree = NearestNeighbors(n_neighbors=k_nn, n_jobs=-1)
+    kdtree = NearestNeighbors(n_neighbors=k_nn, **knn_kwargs)
     kdtree.fit(data)
 
     for unit_ind in range(n):
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index cc56d1c7b7..5a4d81dd7b 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -33,7 +33,7 @@ class KNNMerging(BaseMergingEngine):
             "maximum_distance_um": 100,
             "refractory_period": (0.3, 1.0),
             "corr_diff_thresh": 0.2,
-            "k_nn" : 10
+            "k_nn" : 5
         },
     }
 

From 71c4876cb7481f69b7b468c401751d82b8bdbc8f Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 2 Jul 2024 13:00:17 +0000
Subject: [PATCH 113/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/knn.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index 5a4d81dd7b..55c9f9c835 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -33,7 +33,7 @@ class KNNMerging(BaseMergingEngine):
             "maximum_distance_um": 100,
             "refractory_period": (0.3, 1.0),
             "corr_diff_thresh": 0.2,
-            "k_nn" : 5
+            "k_nn": 5,
         },
     }
 

From 06074506667235c9dda63ea877dfe85138f32d8a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 3 Jul 2024 15:02:55 +0200
Subject: [PATCH 114/164] Adding a curation step for too small SNR

---
 src/spikeinterface/curation/auto_merge.py | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 245c828b9e..ea593ba583 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -15,6 +15,7 @@
 def get_potential_auto_merge(
     sorting_analyzer,
     minimum_spikes=100,
+    minimum_snr=2,
     maximum_distance_um=150.0,
     peak_sign="neg",
     bin_ms=0.25,
@@ -74,6 +75,8 @@ def get_potential_auto_merge(
     minimum_spikes : int, default: 100
         Minimum number of spikes for each unit to consider a potential merge.
         Enough spikes are needed to estimate the correlogram
+    minimum_snr : float, default 2
+        Minimum Signal to Noise ratio for templates to be considered while merging
     maximum_distance_um : float, default: 150
         Maximum distance between units for considering a merge
     peak_sign : "neg" | "pos" | "both", default: "neg"
@@ -148,6 +151,7 @@ def get_potential_auto_merge(
 
     all_steps = [
         "min_spikes",
+        "min_snr",
         "remove_contaminated",
         "unit_positions",
         "correlogram",
@@ -190,6 +194,7 @@ def get_potential_auto_merge(
         elif preset == "knn":
             steps = [
                 "min_spikes",
+                "min_snr",
                 "remove_contaminated",
                 "unit_positions",
                 "knn",
@@ -211,6 +216,19 @@ def get_potential_auto_merge(
             to_remove = num_spikes < minimum_spikes
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
+        
+        # STEP : remove units with too small SNR
+        if step == "min_snr":
+            qm_ext = sorting_analyzer.get_extension("quality_metrics")
+            if qm_ext is None:
+                sorting_analyzer.compute('noise_levels')
+                sorting_analyzer.compute('quality_metrics', metric_names=['snr'])
+                qm_ext = sorting_analyzer.get_extension("quality_metrics")
+
+            snrs = qm_ext.get_data()['snr'].values    
+            to_remove = snrs < minimum_snr
+            pair_mask[to_remove, :] = False
+            pair_mask[:, to_remove] = False
 
         # STEP : remove contaminated auto corr
         elif step == "remove_contaminated":
@@ -294,7 +312,6 @@ def get_potential_auto_merge(
                     template_metric=template_metric,
                     sparsity=sorting_analyzer.sparsity,
                 )
-
             pair_mask = pair_mask & (templates_diff < template_diff_thresh)
             outs["templates_diff"] = templates_diff
 
@@ -374,9 +391,9 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs)
             ind = ind[mask_2]
             chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
             all_counts = all_counts.astype(float)
-            all_counts /= all_spike_counts[chan_inds]
+            #all_counts /= all_spike_counts[chan_inds]
             best_indices = np.argsort(all_counts)[::-1]
-            pair_mask[unit_ind] &= np.isin(np.arange(n), chan_inds[best_indices])
+            pair_mask[unit_ind, unit_ind + 1 :] &= np.isin(np.arange(unit_ind + 1, n), chan_inds[best_indices])
     return pair_mask
 
 

From 1a18a05dcebc9dc18aff4fce9109ba3c2d131220 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 3 Jul 2024 21:49:56 +0200
Subject: [PATCH 115/164] Fixes

---
 src/spikeinterface/curation/auto_merge.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index ea593ba583..a08d513cca 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -178,7 +178,6 @@ def get_potential_auto_merge(
                 "remove_contaminated",
                 "unit_positions",
                 "template_similarity",
-                "correlogram",
                 "presence_distance",
                 "check_increase_score",
             ]
@@ -218,7 +217,7 @@ def get_potential_auto_merge(
             pair_mask[:, to_remove] = False
         
         # STEP : remove units with too small SNR
-        if step == "min_snr":
+        elif step == "min_snr":
             qm_ext = sorting_analyzer.get_extension("quality_metrics")
             if qm_ext is None:
                 sorting_analyzer.compute('noise_levels')
@@ -330,7 +329,7 @@ def get_potential_auto_merge(
         # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
             refractory = (censored_period_ms, refractory_period_ms)
-            CC, p_values = compute_cross_contaminations(sorting_analyzer, pair_mask, CC_threshold, refractory)
+            CC, p_values = compute_cross_contaminations(sorting_analyzer, pair_mask, CC_threshold, refractory, contaminations)
             pair_mask = pair_mask & (p_values > p_value)
             outs["cross_contaminations"] = CC, p_values
 
@@ -539,7 +538,7 @@ def get_unit_adaptive_window(auto_corr: np.ndarray, threshold: float):
     return win_size
 
 
-def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_period):
+def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_period, contaminations=None):
     """
     Looks at a sorting analyzer, and returns statistical tests for cross_contaminations
 
@@ -552,6 +551,7 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
         Any pair above this threshold will not be considered.
     refractory_period : array/list/tuple of 2 floats
         (censored_period_ms, refractory_period_ms)
+    contaminations : contaminations of the units, if already precomputed
 
     """
 
@@ -580,8 +580,12 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
             unit_id2 = unit_ids[unit_ind2]
             spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
             # Compuyting the cross-contamination difference
+            if contaminations is not None:
+                C1 = contaminations[unit_ind1]
+            else:
+                C1 = None
             CC[unit_ind1, unit_ind2], p_values[unit_ind1, unit_ind2] = estimate_cross_contamination(
-                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold
+                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold, contaminations=C1
             )
 
     return CC, p_values

From 25f740a0392b572f7c51afbfaca558c902426fd4 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 4 Jul 2024 08:20:04 +0000
Subject: [PATCH 116/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index a08d513cca..dc50af21ff 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -215,16 +215,16 @@ def get_potential_auto_merge(
             to_remove = num_spikes < minimum_spikes
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
-        
+
         # STEP : remove units with too small SNR
         elif step == "min_snr":
             qm_ext = sorting_analyzer.get_extension("quality_metrics")
             if qm_ext is None:
-                sorting_analyzer.compute('noise_levels')
-                sorting_analyzer.compute('quality_metrics', metric_names=['snr'])
+                sorting_analyzer.compute("noise_levels")
+                sorting_analyzer.compute("quality_metrics", metric_names=["snr"])
                 qm_ext = sorting_analyzer.get_extension("quality_metrics")
 
-            snrs = qm_ext.get_data()['snr'].values    
+            snrs = qm_ext.get_data()["snr"].values
             to_remove = snrs < minimum_snr
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
@@ -329,7 +329,9 @@ def get_potential_auto_merge(
         # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
             refractory = (censored_period_ms, refractory_period_ms)
-            CC, p_values = compute_cross_contaminations(sorting_analyzer, pair_mask, CC_threshold, refractory, contaminations)
+            CC, p_values = compute_cross_contaminations(
+                sorting_analyzer, pair_mask, CC_threshold, refractory, contaminations
+            )
             pair_mask = pair_mask & (p_values > p_value)
             outs["cross_contaminations"] = CC, p_values
 
@@ -390,7 +392,7 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs)
             ind = ind[mask_2]
             chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
             all_counts = all_counts.astype(float)
-            #all_counts /= all_spike_counts[chan_inds]
+            # all_counts /= all_spike_counts[chan_inds]
             best_indices = np.argsort(all_counts)[::-1]
             pair_mask[unit_ind, unit_ind + 1 :] &= np.isin(np.arange(unit_ind + 1, n), chan_inds[best_indices])
     return pair_mask

From a0bb32146ceea37addb3cbbf5d4d7c010dce77ce Mon Sep 17 00:00:00 2001
From: Alessio Buccino <alejoe9187@gmail.com>
Date: Thu, 4 Jul 2024 11:42:19 +0200
Subject: [PATCH 117/164] cleanup, tests, automerge recordingless +
 multi-segment

---
 src/spikeinterface/curation/auto_merge.py     | 158 ++++++++++--------
 .../curation/merge_temporal_splits.py         |  77 ++++++---
 .../curation/tests/test_auto_merge.py         |  67 +++++---
 .../sortingcomponents/merging/lussac.py       | 113 +++++++++----
 4 files changed, 255 insertions(+), 160 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index a08d513cca..e3bce1f912 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from typing import Tuple
 import numpy as np
 
-from ..core import create_sorting_analyzer
+from ..core import create_sorting_analyzer, SortingAnalyzer
 from ..core.template import Templates
 from ..core.template_tools import get_template_extremum_channel
 from ..postprocessing import compute_correlograms
@@ -13,35 +14,35 @@
 
 
 def get_potential_auto_merge(
-    sorting_analyzer,
-    minimum_spikes=100,
-    minimum_snr=2,
-    maximum_distance_um=150.0,
-    peak_sign="neg",
-    bin_ms=0.25,
-    window_ms=100.0,
-    corr_diff_thresh=0.16,
-    template_diff_thresh=0.25,
-    censored_period_ms=0.3,
-    refractory_period_ms=1.0,
-    sigma_smooth_ms=0.6,
-    contamination_threshold=0.2,
-    adaptative_window_threshold=0.5,
+    sorting_analyzer: SortingAnalyzer,
+    preset: str | None = "lussac",
+    minimum_spikes: int = 100,
+    minimum_snr: float = 2,
+    maximum_distance_um: float = 150.0,
+    peak_sign: str = "neg",
+    bin_ms: float = 0.25,
+    window_ms: float = 100.0,
+    corr_diff_thresh: float = 0.16,
+    template_diff_thresh: float = 0.25,
+    censored_period_ms: float = 0.3,
+    refractory_period_ms: float = 1.0,
+    sigma_smooth_ms: float = 0.6,
+    contamination_threshold: float = 0.2,
+    adaptative_window_threshold: float = 0.5,
     censor_correlograms_ms: float = 0.15,
-    num_channels=5,
-    num_shift=5,
-    firing_contamination_balance=2.5,
-    extra_outputs=False,
-    steps=None,
-    presence_distance_thresh=100,
-    preset=None,
-    template_metric="l1",
-    p_value=0.2,
-    CC_threshold=0.1,
-    k_nn=10,
-    knn_kwargs=None,
-    **presence_distance_kwargs,
-):
+    num_channels: int = 5,
+    num_shift: int = 5,
+    firing_contamination_balance: float = 2.5,
+    extra_outputs: bool = False,
+    steps: list[str] | None = None,
+    presence_distance_thresh: float = 100,
+    template_metric: str = "l1",
+    p_value: float = 0.2,
+    CC_threshold: float = 0.1,
+    k_nn: int = 10,
+    knn_kwargs: dict | None = None,
+    presence_distance_kwargs: dict | None = None,
+) -> list[tuple[int | str, int | str]] | Tuple[tuple[int | str, int | str], dict]:
     """
     Algorithm to find and check potential merges between units.
 
@@ -72,6 +73,15 @@ def get_potential_auto_merge(
     ----------
     sorting_analyzer : SortingAnalyzer
         The SortingAnalyzer
+    preset : "lussac" | "temporal_splits" | "knn" | None, default: "lussac"
+        The preset to use for the auto-merge. Presets combine different steps into a recipe:
+        * "lussac" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions", "correlogram",
+            "template_similarity", "cross_contamination", "check_increase_score"
+        * "temporal_splits" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions",
+            "template_similarity", "presence_distance", "check_increase_score"
+        * "knn" uses the following steps: "min_spikes", "min_snr", "remove_contaminated", "unit_positions", "knn",
+            "correlogram", "check_increase_score"
+        If `preset` is None, you can specify the steps manually with the `steps` parameter.
     minimum_spikes : int, default: 100
         Minimum number of spikes for each unit to consider a potential merge.
         Enough spikes are needed to estimate the correlogram
@@ -91,42 +101,42 @@ def get_potential_auto_merge(
     template_diff_thresh : float, default: 0.25
         The threshold on the "template distance metric" for considering a merge.
         It needs to be between 0 and 1
-    template_metric : 'l1'
-        The metric to be used when comparing templates. Default is l1 norm
+    template_metric : 'l1' | 'l2' | 'cosine', default: 'l1'
+        The metric to be used when comparing templates.
     censored_period_ms : float, default: 0.3
-        Used to compute the refractory period violations aka "contamination"
+        Used to compute the refractory period violations aka "contamination".
     refractory_period_ms : float, default: 1
-        Used to compute the refractory period violations aka "contamination"
+        Used to compute the refractory period violations aka "contamination".
     sigma_smooth_ms : float, default: 0.6
-        Parameters to smooth the correlogram estimation
+        Parameters to smooth the correlogram estimation.
     contamination_threshold : float, default: 0.2
-        Threshold for not taking in account a unit when it is too contaminated
+        Threshold for not taking in account a unit when it is too contaminated.
     adaptative_window_threshold : : float, default: 0.5
-        Parameter to detect the window size in correlogram estimation
+        Parameter to detect the window size in correlogram estimation.
     censor_correlograms_ms : float, default: 0.15
-        The period to censor on the auto and cross-correlograms
+        The period to censor on the auto and cross-correlograms.
     num_channels : int, default: 5
-        Number of channel to use for template similarity computation
+        Number of channel to use for template similarity computation.
     num_shift : int, default: 5
-        Number of shifts in samles to be explored for template similarity computation
+        Number of shifts in samles to be explored for template similarity computation.
     firing_contamination_balance : float, default: 2.5
-        Parameter to control the balance between firing rate and contamination in computing unit "quality score"
+        Parameter to control the balance between firing rate and contamination in computing unit "quality score".
     presence_distance_thresh : float, default: 100
-        Parameter to control how present two units should be simultaneously
+        Parameter to control how present two units should be simultaneously.
     k_nn : int, default 5
-        The number of neighbors to consider for every spike in the recording
+        The number of neighbors to consider for every spike in the recording.
     knn_kwargs : dict, default None
-        The dict of extra params to be passed to knn
+        The dict of extra params to be passed to knn.
+    presence_distance_kwargs : dict, default None
+        The dict of extra params to be passed to presence_distance.
     extra_outputs : bool, default: False
-        If True, an additional dictionary (`outs`) with processed data is returned
+        If True, an additional dictionary (`outs`) with processed data is returned.
     steps : None or list of str, default: None
         which steps to run (gives flexibility to running just some steps)
         If None all steps are done (except presence_distance).
         Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram",
         "template_similarity", "presence_distance", "cross_contamination", "knn", "check_increase_score"
         Please check steps explanations above!
-    template_metric : 'l1', 'l2' or 'cosine'
-        The metric to consider when measuring the distances between templates. Default is l1
 
     Returns
     -------
@@ -140,9 +150,7 @@ def get_potential_auto_merge(
     import scipy
 
     sorting = sorting_analyzer.sorting
-    recording = sorting_analyzer.recording
     unit_ids = sorting.unit_ids
-    sorting.register_recording(recording)
 
     # to get fast computation we will not analyse pairs when:
     #    * not enough spikes for one of theses
@@ -164,14 +172,8 @@ def get_potential_auto_merge(
 
     if steps is None:
         if preset is None:
-            steps = [
-                "min_spikes",
-                "remove_contaminated",
-                "unit_positions",
-                "template_similarity",
-                "correlogram",
-                "check_increase_score",
-            ]
+            if steps is None:
+                raise ValueError("You need to specify a preset or steps for the auto-merge function")
         elif preset == "temporal_splits":
             steps = [
                 "min_spikes",
@@ -191,6 +193,10 @@ def get_potential_auto_merge(
                 "check_increase_score",
             ]
         elif preset == "knn":
+            if not sorting_analyzer.has_extension("spike_locations"):
+                raise ValueError("knn preset requires spike_locations extension")
+            if not sorting_analyzer.has_extension("spike_amplitudes"):
+                raise ValueError("knn preset requires spike_amplitudes extension")
             steps = [
                 "min_spikes",
                 "min_snr",
@@ -215,16 +221,16 @@ def get_potential_auto_merge(
             to_remove = num_spikes < minimum_spikes
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
-        
+
         # STEP : remove units with too small SNR
         elif step == "min_snr":
             qm_ext = sorting_analyzer.get_extension("quality_metrics")
             if qm_ext is None:
-                sorting_analyzer.compute('noise_levels')
-                sorting_analyzer.compute('quality_metrics', metric_names=['snr'])
+                sorting_analyzer.compute("noise_levels")
+                sorting_analyzer.compute("quality_metrics", metric_names=["snr"])
                 qm_ext = sorting_analyzer.get_extension("quality_metrics")
 
-            snrs = qm_ext.get_data()['snr'].values    
+            snrs = qm_ext.get_data()["snr"].values
             to_remove = snrs < minimum_snr
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
@@ -322,14 +328,22 @@ def get_potential_auto_merge(
 
         # STEP : check how the rates overlap in times
         elif step == "presence_distance" in steps:
-            presence_distances = compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs)
+            presence_distance_kwargs = presence_distance_kwargs or dict()
+            num_samples = [
+                sorting_analyzer.get_num_samples(segment_index) for segment_index in range(sorting.get_num_segments())
+            ]
+            presence_distances = compute_presence_distance(
+                sorting, pair_mask, num_samples=num_samples, **presence_distance_kwargs
+            )
             pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
             outs["presence_distances"] = presence_distances
 
         # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
             refractory = (censored_period_ms, refractory_period_ms)
-            CC, p_values = compute_cross_contaminations(sorting_analyzer, pair_mask, CC_threshold, refractory, contaminations)
+            CC, p_values = compute_cross_contaminations(
+                sorting_analyzer, pair_mask, CC_threshold, refractory, contaminations
+            )
             pair_mask = pair_mask & (p_values > p_value)
             outs["cross_contaminations"] = CC, p_values
 
@@ -390,7 +404,7 @@ def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs)
             ind = ind[mask_2]
             chan_inds, all_counts = np.unique(spikes["unit_index"][ind], return_counts=True)
             all_counts = all_counts.astype(float)
-            #all_counts /= all_spike_counts[chan_inds]
+            # all_counts /= all_spike_counts[chan_inds]
             best_indices = np.argsort(all_counts)[::-1]
             pair_mask[unit_ind, unit_ind + 1 :] &= np.isin(np.arange(unit_ind + 1, n), chan_inds[best_indices])
     return pair_mask
@@ -554,13 +568,13 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
     contaminations : contaminations of the units, if already precomputed
 
     """
+    from spikeinterface.sortingcomponents.merging.lussac import estimate_cross_contamination
 
     sorting = analyzer.sorting
     unit_ids = sorting.unit_ids
     n = len(unit_ids)
-    sf = analyzer.recording.sampling_frequency
-    n_frames = analyzer.recording.get_num_samples()
-    from spikeinterface.sortingcomponents.merging.lussac import estimate_cross_contamination
+    sf = analyzer.sampling_frequency
+    n_frames = analyzer.get_total_samples()
 
     if pair_mask is None:
         pair_mask = np.ones((n, n), dtype="bool")
@@ -585,7 +599,7 @@ def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_p
             else:
                 C1 = None
             CC[unit_ind1, unit_ind2], p_values[unit_ind1, unit_ind2] = estimate_cross_contamination(
-                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold, contaminations=C1
+                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold, C1=C1
             )
 
     return CC, p_values
@@ -692,7 +706,6 @@ def check_improve_contaminations_score(
     Check that the contamination score is improved (decrease)  after
     a potential merge
     """
-    recording = sorting_analyzer.recording
     sorting = sorting_analyzer.sorting
     pair_mask = pair_mask.copy()
     pairs_removed = []
@@ -715,7 +728,14 @@ def check_improve_contaminations_score(
             sorting, [[unit_id1, unit_id2]], new_unit_ids=[unit_id1], delta_time_ms=censored_period_ms
         ).select_units([unit_id1])
 
-        sorting_analyzer_new = create_sorting_analyzer(sorting_merged, recording, format="memory", sparse=False)
+        # create recordingless analyzer
+        sorting_analyzer_new = SortingAnalyzer(
+            sorting=sorting_merged,
+            recording=None,
+            rec_attributes=sorting_analyzer.rec_attributes,
+            format="memory",
+            sparsity=None,
+        )
 
         new_contaminations, _ = compute_refrac_period_violations(
             sorting_analyzer_new, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
index 96c1e0bfe1..44b189abe7 100644
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ b/src/spikeinterface/curation/merge_temporal_splits.py
@@ -2,7 +2,7 @@
 import numpy as np
 
 
-def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None):
+def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None, num_samples=None):
     """
     Compute the presence distance between two units.
 
@@ -11,61 +11,84 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None):
 
     Parameters
     ----------
-    sorting: Sorting
+    sorting : Sorting
         The sorting object.
-    unit1: int or str
+    unit1 : int or str
         The id of the first unit.
-    unit2: int or str
+    unit2 : int or str
         The id of the second unit.
-    bin_duration_s: float
+    bin_duration_s : float
         The duration of the bin in seconds.
-    bins: array-like
+    bins : array-like
         The bins used to compute the firing rate.
+    num_samples : list | int | None, default: None
+        The number of samples for each segment. Required if the sorting doesn't have a recording
+        attached.
 
     Returns
     -------
-    d: float
+    d : float
         The presence distance between the two units.
     """
-    if bins is None:
-        bin_size = bin_duration_s * sorting.sampling_frequency
-        bins = np.arange(0, sorting.get_num_samples(), bin_size)
+    import scipy
 
-    st1 = sorting.get_unit_spike_train(unit_id=unit1)
-    st2 = sorting.get_unit_spike_train(unit_id=unit2)
+    distances = []
+    if num_samples is not None:
+        if isinstance(num_samples, int):
+            num_samples = [num_samples]
 
-    h1, _ = np.histogram(st1, bins)
-    h1 = h1.astype(float)
+    if not sorting.has_recording():
+        if num_samples is None:
+            raise ValueError("num_samples must be provided if sorting has no recording")
+        if len(num_samples) != sorting.get_num_segments():
+            raise ValueError("num_samples must have the same length as the number of segments")
 
-    h2, _ = np.histogram(st2, bins)
-    h2 = h2.astype(float)
+    for segment_index in range(sorting.get_num_segments()):
+        if bins is None:
+            bin_size = bin_duration_s * sorting.sampling_frequency
+            if sorting.has_recording():
+                ns = sorting.get_num_samples(segment_index)
+            else:
+                ns = num_samples[segment_index]
+            bins = np.arange(0, ns, bin_size)
 
-    import scipy
+        st1 = sorting.get_unit_spike_train(unit_id=unit1)
+        st2 = sorting.get_unit_spike_train(unit_id=unit2)
+
+        h1, _ = np.histogram(st1, bins)
+        h1 = h1.astype(float)
+
+        h2, _ = np.histogram(st2, bins)
+        h2 = h2.astype(float)
 
-    xaxis = bins[1:] / sorting.sampling_frequency
-    d = scipy.stats.wasserstein_distance(xaxis, xaxis, h1, h2)
+        xaxis = bins[1:] / sorting.sampling_frequency
+        d = scipy.stats.wasserstein_distance(xaxis, xaxis, h1, h2)
+        distances.append(d)
 
-    return d
+    return np.mean(d)
 
 
-def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
+def compute_presence_distance(sorting, pair_mask, num_samples=None, **presence_distance_kwargs):
     """
     Get the potential drift-related merges based on similarity and presence completeness.
 
     Parameters
     ----------
-    sorting: Sorting
+    sorting : Sorting
         The sorting object
-    pair_mask: None or boolean array
+    pair_mask : None or boolean array
         A bool matrix of size (num_units, num_units) to select
         which pair to compute.
-    presence_distance_threshold: float
+    num_samples : list | int | None, default: None
+        The number of samples for each segment. Required if the sorting doesn't have a recording
+        attached.
+    presence_distance_threshold : float
         The presence distance threshold used to consider two units as similar
-    presence_distance_kwargs: A dictionary of kwargs to be passed to compute_presence_distance()
+    presence_distance_kwargs : A dictionary of kwargs to be passed to compute_presence_distance().
 
     Returns
     -------
-    potential_merges: list
+    potential_merges : list
         The list of potential merges
 
     """
@@ -84,7 +107,7 @@ def compute_presence_distance(sorting, pair_mask, **presence_distance_kwargs):
                 continue
             unit1 = unit_ids[unit_ind1]
             unit2 = unit_ids[unit_ind2]
-            d = presence_distance(sorting, unit1, unit2, **presence_distance_kwargs)
+            d = presence_distance(sorting, unit1, unit2, num_samples=num_samples, **presence_distance_kwargs)
             presence_distances[unit_ind1, unit_ind2] = d
 
     return presence_distances
diff --git a/src/spikeinterface/curation/tests/test_auto_merge.py b/src/spikeinterface/curation/tests/test_auto_merge.py
index 93c302f1f6..89f38c8429 100644
--- a/src/spikeinterface/curation/tests/test_auto_merge.py
+++ b/src/spikeinterface/curation/tests/test_auto_merge.py
@@ -12,8 +12,10 @@
 from spikeinterface.curation.tests.common import make_sorting_analyzer, sorting_analyzer_for_curation
 
 
-def test_get_auto_merge_list(sorting_analyzer_for_curation):
+@pytest.mark.parametrize("preset", ["lussac", "knn", "temporal_splits", None])
+def test_get_auto_merge_list(sorting_analyzer_for_curation, preset):
 
+    print(sorting_analyzer_for_curation)
     sorting = sorting_analyzer_for_curation.sorting
     recording = sorting_analyzer_for_curation.recording
     num_unit_splited = 1
@@ -34,32 +36,43 @@ def test_get_auto_merge_list(sorting_analyzer_for_curation):
     sorting_analyzer.compute("random_spikes")
     sorting_analyzer.compute("waveforms", **job_kwargs)
     sorting_analyzer.compute("templates")
-
-    potential_merges, outs = get_potential_auto_merge(
-        sorting_analyzer,
-        minimum_spikes=1000,
-        maximum_distance_um=150.0,
-        peak_sign="neg",
-        bin_ms=0.25,
-        window_ms=100.0,
-        corr_diff_thresh=0.16,
-        template_diff_thresh=0.25,
-        censored_period_ms=0.0,
-        refractory_period_ms=4.0,
-        sigma_smooth_ms=0.6,
-        contamination_threshold=0.2,
-        adaptative_window_threshold=0.5,
-        num_channels=5,
-        num_shift=5,
-        firing_contamination_balance=1.5,
-        extra_outputs=True,
-    )
-
-    assert len(potential_merges) == num_unit_splited
-    for true_pair in other_ids.values():
-        true_pair = tuple(true_pair)
-        assert true_pair in potential_merges
-
+    sorting_analyzer.compute(["spike_amplitudes", "spike_locations"])
+
+    if preset is not None:
+        potential_merges, outs = get_potential_auto_merge(
+            sorting_analyzer,
+            preset=preset,
+            minimum_spikes=1000,
+            maximum_distance_um=150.0,
+            peak_sign="neg",
+            bin_ms=0.25,
+            window_ms=100.0,
+            corr_diff_thresh=0.16,
+            template_diff_thresh=0.25,
+            censored_period_ms=0.0,
+            refractory_period_ms=4.0,
+            sigma_smooth_ms=0.6,
+            contamination_threshold=0.2,
+            adaptative_window_threshold=0.5,
+            num_channels=5,
+            num_shift=5,
+            firing_contamination_balance=1.5,
+            extra_outputs=True,
+        )
+        if preset == "lussac":
+            assert len(potential_merges) == num_unit_splited
+            for true_pair in other_ids.values():
+                true_pair = tuple(true_pair)
+                assert true_pair in potential_merges
+    else:
+        # when preset is None you have to specify the steps
+        with pytest.raises(ValueError):
+            potential_merges = get_potential_auto_merge(sorting_analyzer, preset=preset)
+        potential_merges = get_potential_auto_merge(
+            sorting_analyzer, preset=preset, steps=["min_spikes", "min_snr", "remove_contaminated", "unit_positions"]
+        )
+
+    # DEBUG
     # import matplotlib.pyplot as plt
     # from spikeinterface.curation.auto_merge import normalize_correlogram
     # templates_diff = outs['templates_diff']
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 393c6d4cc1..dede0efeb1 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -20,16 +20,19 @@
 def binom_sf(x: int, n: float, p: float) -> float:
     """
     Computes the survival function (sf = 1 - cdf) of the binomial distribution.
-    From values where the cdf is really close to 1.0, the survival function gives more precise results.
-    Allows for a non-integer n (uses interpolation).
 
-    @param x : int
+    Parameters
+    ----------
+    x : int
         The number of successes.
-    @param n : float
+    n : float
         The number of trials.
-    @param p: float
+    p : float
         The probability of success.
-    @return sf : float
+
+    Returns
+    -------
+    sf : float
         The survival function of the binomial distribution.
     """
 
@@ -51,10 +54,21 @@ def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
         """
         Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
 
-        @param max_time : float
+        Parameters
+        ----------
+        max_time : float
             The maximum time between 2 spikes to be considered as a coincidence.
-        @return border_low, border_high, p_low, p_high: tuple[int, int, float, float]
-            The borders and their probabilities.
+
+        Returns
+        -------
+        border_low : int
+            The lower border.
+        border_high : int
+            The higher border.
+        p_low : float
+            The probability of 2 spikes distant by the lower border to be closer than max_time.
+        p_high : float
+            The probability of 2 spikes distant by the higher border to be closer than max_time.
         """
 
         border_high = math.ceil(max_time)
@@ -72,11 +86,16 @@ def compute_nb_violations(spike_train, max_time) -> float:
         """
         Computes the number of refractory period violations in a spike train.
 
-        @param spike_train : array[int64] (n_spikes)
+        Parameters
+        ----------
+        spike_train : array[int64] (n_spikes)
             The spike train to compute the number of violations for.
-        @param max_time : float32
+        max_time : float32
             The maximum time to consider for violations (in number of samples).
-        @return n_violations : float
+
+        Returns
+        -------
+        n_violations : float
             The number of spike pairs that violate the refractory period.
         """
 
@@ -107,20 +126,19 @@ def compute_nb_violations(spike_train, max_time) -> float:
     def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
         """
         Computes the number of coincident spikes between two spike trains.
-        Spike timings are integers, so their real timing follows a uniform distribution between t - dt/2 and t + dt/2.
-        Under the assumption that the uniform distributions from two spikes are independent, we can compute the probability
-        of those two spikes being closer than the coincidence window:
-        f(x) = 1/2 (x+1)² if -1 <= x <= 0
-        f(x) = 1/2 (1-x²) + x if 0 <= x <= 1
-        where x is the distance between max_time floor/ceil(max_time)
-
-        @param spike_train1 : array[int64] (n_spikes1)
+
+        Parameters
+        ----------
+        spike_train1 : array[int64] (n_spikes1)
             The spike train of the first unit.
-        @param spike_train2 : array[int64] (n_spikes2)
+        spike_train2 : array[int64] (n_spikes2)
             The spike train of the second unit.
-        @param max_time : float32
+        max_time : float32
             The maximum time to consider for coincidence (in number samples).
-        @return n_coincidence : float
+
+        Returns
+        -------
+        n_coincidence : float
             The number of coincident spikes.
         """
 
@@ -155,15 +173,21 @@ def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
 def estimate_contamination(spike_train: np.ndarray, sf: float, T: int, refractory_period: tuple[float, float]) -> float:
     """
     Estimates the contamination of a spike train by looking at the number of refractory period violations.
-    The spike train is assumed to have spikes coming from a neuron, and noisy spikes that are random and
-    uncorrelated to the neuron. Under this assumption, we can estimate the contamination (i.e. the
-    fraction of noisy spikes to the total number of spikes).
 
-    @param spike_train : np.ndarray
+    Parameters
+    ----------
+    spike_train : np.ndarray
         The unit's spike train.
-    @param refractory_period : tuple[float, float]
+    sf : float
+        The sampling frequency of the spike train.
+    T : int
+        The duration of the spike train in samples.
+    refractory_period : tuple[float, float]
         The censored and refractory period (t_c, t_r) used (in ms).
-    @return estimated_contamination : float
+
+    Returns
+    -------
+    estimated_contamination : float
         The estimated contamination between 0 and 1.
     """
 
@@ -185,29 +209,44 @@ def estimate_cross_contamination(
     T: int,
     refractory_period: tuple[float, float],
     limit: float | None = None,
+    C1: np.ndarray | None = None,
 ) -> tuple[float, float] | float:
     """
     Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
     Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
 
-    @param spike_train1 : np.ndarray
+    Parameters
+    ----------
+    spike_train1 : np.ndarray
         The spike train of the first unit.
-    @param spike_train2 : np.ndarray
+    spike_train2 : np.ndarray
         The spike train of the second unit.
-    @param refractory_period : tuple[float, float]
+    sf : float
+        The sampling frequency (in Hz).
+    T : int
+        The duration of the recording (in samples).
+    refractory_period : tuple[float, float]
         The censored and refractory period (t_c, t_r) used (in ms).
-    @param limit : float | None
+    limit : float, optional
         The higher limit of cross-contamination for the statistical test.
-    @return (estimated_cross_cont, p_value) : tuple[float, float] if limit is not None
-            estimated_cross_cont: float if limit is None
-        Returns the estimation of cross-contamination, as well as the p-value of the statistical test if the limit is given.
+    C1 : np.ndarray, optional
+        The contamination estimate of the first spike train.
+
+    Returns
+    -------
+    (estimated_cross_cont, p_value) : tuple[float, float] if limit is not None
+        estimated_cross_cont : float if limit is None
+            The estimation of cross-contamination.
+        p_value : float
+            The p-value of the statistical test if the limit is given.
     """
     spike_train1 = spike_train1.astype(np.int64, copy=False)
     spike_train2 = spike_train2.astype(np.int64, copy=False)
 
     N1 = float(len(spike_train1))
     N2 = float(len(spike_train2))
-    C1 = estimate_contamination(spike_train1, sf, T, refractory_period)
+    if C1 is None:
+        C1 = estimate_contamination(spike_train1, sf, T, refractory_period)
 
     t_c = int(round(refractory_period[0] * 1e-3 * sf))
     t_r = int(round(refractory_period[1] * 1e-3 * sf))

From ae51c3addeb4ce8039766f789e15b1f87a4a9b68 Mon Sep 17 00:00:00 2001
From: Alessio Buccino <alejoe9187@gmail.com>
Date: Thu, 4 Jul 2024 12:08:14 +0200
Subject: [PATCH 118/164] fix tests

---
 src/spikeinterface/preprocessing/motion.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/spikeinterface/preprocessing/motion.py b/src/spikeinterface/preprocessing/motion.py
index a445095ec7..57fe609e91 100644
--- a/src/spikeinterface/preprocessing/motion.py
+++ b/src/spikeinterface/preprocessing/motion.py
@@ -206,6 +206,7 @@ def correct_motion(
     preset="nonrigid_accurate",
     folder=None,
     output_motion_info=False,
+    overwrite=False,
     detect_kwargs={},
     select_kwargs={},
     localize_peaks_kwargs={},

From e1c3c31b65fe0f55ea1f518d87e868815ed92028 Mon Sep 17 00:00:00 2001
From: Alessio Buccino <alejoe9187@gmail.com>
Date: Thu, 4 Jul 2024 13:13:57 +0200
Subject: [PATCH 119/164] fix lussac meta-merging component

---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index dede0efeb1..ee8c2fb66b 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -285,7 +285,8 @@ class LussacMerging(BaseMergingEngine):
         "lussac_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um": 50,
-            "refractory_period": (0.3, 1.0),
+            "censored_period_ms": 0.3,
+            "refractory_period_ms": 1.0,
             "template_diff_thresh": 0.5,
         },
     }

From bb127c9bd2f3ac1e21fd42868139f5ec8ad62f82 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 4 Jul 2024 15:52:20 +0200
Subject: [PATCH 120/164] Bring back the default mode for auto_merge

---
 src/spikeinterface/curation/auto_merge.py     | 20 ++++++++++++++-----
 .../sortingcomponents/merging/circus.py       |  1 -
 .../sortingcomponents/merging/knn.py          |  5 +++--
 .../sortingcomponents/merging/lussac.py       |  4 ++--
 4 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index e3bce1f912..f83d9494c2 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -73,14 +73,16 @@ def get_potential_auto_merge(
     ----------
     sorting_analyzer : SortingAnalyzer
         The SortingAnalyzer
-    preset : "lussac" | "temporal_splits" | "knn" | None, default: "lussac"
+    preset : "default" | "lussac" | "temporal_splits" | "knn" | None, default: "default"
         The preset to use for the auto-merge. Presets combine different steps into a recipe:
-        * "lussac" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions", "correlogram",
+        * "default" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions",
+            "template_similarity", "correlogram", "check_increase_score"
+        * "lussac" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions",
             "template_similarity", "cross_contamination", "check_increase_score"
         * "temporal_splits" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions",
             "template_similarity", "presence_distance", "check_increase_score"
-        * "knn" uses the following steps: "min_spikes", "min_snr", "remove_contaminated", "unit_positions", "knn",
-            "correlogram", "check_increase_score"
+        * "knn" uses the following steps: "min_spikes", "min_snr", "remove_contaminated", "unit_positions", 
+            "knn", "check_increase_score"
         If `preset` is None, you can specify the steps manually with the `steps` parameter.
     minimum_spikes : int, default: 100
         Minimum number of spikes for each unit to consider a potential merge.
@@ -174,6 +176,15 @@ def get_potential_auto_merge(
         if preset is None:
             if steps is None:
                 raise ValueError("You need to specify a preset or steps for the auto-merge function")
+        elif preset == "default":
+            steps = [
+                "min_spikes",
+                "remove_contaminated",
+                "unit_positions",
+                "template_similarity",
+                "correlogram",
+                "check_increase_score",
+            ]
         elif preset == "temporal_splits":
             steps = [
                 "min_spikes",
@@ -203,7 +214,6 @@ def get_potential_auto_merge(
                 "remove_contaminated",
                 "unit_positions",
                 "knn",
-                "correlogram",
                 "check_increase_score",
             ]
 
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 8ee64276d4..2ea91bd191 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -25,7 +25,6 @@ class CircusMerging(BaseMergingEngine):
             "minimum_spikes": 50,
             "corr_diff_thresh": 0.5,
             "maximum_distance_um": 50,
-            "presence_distance_thresh": 100,
             "template_diff_thresh": 0.5,
         },
         "temporal_splits_kwargs": {
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index 55c9f9c835..f462a71ff8 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -30,8 +30,9 @@ class KNNMerging(BaseMergingEngine):
         "recursive": True,
         "knn_kwargs": {
             "minimum_spikes": 50,
-            "maximum_distance_um": 100,
-            "refractory_period": (0.3, 1.0),
+            "maximum_distance_um": 50,
+            "censored_period_ms": 0.3,
+            "refractory_period_ms": 1.0,
             "corr_diff_thresh": 0.2,
             "k_nn": 5,
         },
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index ee8c2fb66b..26db9c5ef5 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -209,7 +209,7 @@ def estimate_cross_contamination(
     T: int,
     refractory_period: tuple[float, float],
     limit: float | None = None,
-    C1: np.ndarray | None = None,
+    C1: float | None = None,
 ) -> tuple[float, float] | float:
     """
     Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
@@ -229,7 +229,7 @@ def estimate_cross_contamination(
         The censored and refractory period (t_c, t_r) used (in ms).
     limit : float, optional
         The higher limit of cross-contamination for the statistical test.
-    C1 : np.ndarray, optional
+    C1 : float, optional
         The contamination estimate of the first spike train.
 
     Returns

From fc36bdc86712c9923b0dc96b991ca1b67c6da92b Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 4 Jul 2024 13:53:30 +0000
Subject: [PATCH 121/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index f83d9494c2..90f53cb74d 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -81,7 +81,7 @@ def get_potential_auto_merge(
             "template_similarity", "cross_contamination", "check_increase_score"
         * "temporal_splits" uses the following steps: "min_spikes", "remove_contaminated", "unit_positions",
             "template_similarity", "presence_distance", "check_increase_score"
-        * "knn" uses the following steps: "min_spikes", "min_snr", "remove_contaminated", "unit_positions", 
+        * "knn" uses the following steps: "min_spikes", "min_snr", "remove_contaminated", "unit_positions",
             "knn", "check_increase_score"
         If `preset` is None, you can specify the steps manually with the `steps` parameter.
     minimum_spikes : int, default: 100

From 6c85de474d232e339a9c2315f552cce208a4c916 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 4 Jul 2024 16:09:15 +0200
Subject: [PATCH 122/164] Bring back default old behaviour

---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index f83d9494c2..11cecf1523 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -15,7 +15,7 @@
 
 def get_potential_auto_merge(
     sorting_analyzer: SortingAnalyzer,
-    preset: str | None = "lussac",
+    preset: str | None = "default",
     minimum_spikes: int = 100,
     minimum_snr: float = 2,
     maximum_distance_um: float = 150.0,

From d6d673a6dd38068603f801ddceabcf565c63236b Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 5 Jul 2024 09:09:23 +0200
Subject: [PATCH 123/164] Docs

---
 src/spikeinterface/curation/auto_merge.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index f53c84d741..bee52dd7ae 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -57,8 +57,8 @@ def get_potential_auto_merge(
         * STEP 3: estimated unit locations are close enough (`maximum_distance_um`)
         * STEP 4: the cross-correlograms of the two units are similar to each auto-corrleogram (`corr_diff_thresh`)
         * STEP 5: the templates of the two units are similar (`template_diff_thresh`)
-        * STEP 6: [optional] the presence distance of two units
-        * STEP 7: [optional] the cross-contamination is not significant
+        * STEP 6: the presence distance of two units
+        * STEP 7: the cross-contamination is not significant
         * STEP 8: the unit "quality score" is increased after the merge.
 
     The "quality score" factors in the increase in firing rate (**f**) due to the merge and a possible increase in

From 01e5cc129c3241619277875e23f12c8af71361c4 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sun, 7 Jul 2024 15:54:15 +0000
Subject: [PATCH 124/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/core/sorting_tools.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/spikeinterface/core/sorting_tools.py b/src/spikeinterface/core/sorting_tools.py
index cb7ae5051c..918d95bf52 100644
--- a/src/spikeinterface/core/sorting_tools.py
+++ b/src/spikeinterface/core/sorting_tools.py
@@ -225,7 +225,6 @@ def random_spikes_selection(
     return random_spikes_indices
 
 
-
 def apply_merges_to_sorting(
     sorting, units_to_merge, new_unit_ids=None, censor_ms=None, return_kept=False, new_id_strategy="append"
 ):

From 84dea852c0828b33d10ca8d59d8b15cd9358682d Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Mon, 8 Jul 2024 07:09:11 +0200
Subject: [PATCH 125/164] rebasing

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 2 +-
 src/spikeinterface/sortingcomponents/merging/knn.py    | 2 +-
 src/spikeinterface/sortingcomponents/merging/lussac.py | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 2ea91bd191..beafecf0e8 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -80,7 +80,7 @@ def _get_new_sorting(self):
                 print(f"{len(more_merges)} merges have been detected via additional temporal splits")
             merges += more_merges
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting, _ = apply_merges_to_sorting(
+        new_sorting = apply_merges_to_sorting(
             self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
         )
         return new_sorting, merges
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index f462a71ff8..a36d692713 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -76,7 +76,7 @@ def _get_new_sorting(self):
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting, _ = apply_merges_to_sorting(
+        new_sorting = apply_merges_to_sorting(
             self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
         )
         return new_sorting, merges
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 26db9c5ef5..f763e36159 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -328,7 +328,7 @@ def _get_new_sorting(self):
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting, _ = apply_merges_to_sorting(
+        new_sorting = apply_merges_to_sorting(
             self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
         )
         return new_sorting, merges

From d697b8ced3042fea33d0899f1979dcc190d41903 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 8 Jul 2024 05:09:53 +0000
Subject: [PATCH 126/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 4 +---
 src/spikeinterface/sortingcomponents/merging/knn.py    | 4 +---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 4 +---
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index beafecf0e8..84c9beee1e 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -80,9 +80,7 @@ def _get_new_sorting(self):
                 print(f"{len(more_merges)} merges have been detected via additional temporal splits")
             merges += more_merges
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(
-            self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
-        )
+        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"])
         return new_sorting, merges
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index a36d692713..67ccb51dc9 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -76,9 +76,7 @@ def _get_new_sorting(self):
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(
-            self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
-        )
+        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"])
         return new_sorting, merges
 
     def run(self, extra_outputs=False):
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index f763e36159..d8a056dd01 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -328,9 +328,7 @@ def _get_new_sorting(self):
         if self.verbose:
             print(f"{len(merges)} merges have been detected")
         units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(
-            self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"]
-        )
+        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"])
         return new_sorting, merges
 
     def run(self, extra_outputs=False):

From bd61e1bd8bd81a1515fe9e788583c07c31c0672e Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Tue, 9 Jul 2024 11:32:12 +0200
Subject: [PATCH 127/164] polishing

---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 7 ++++---
 src/spikeinterface/sortingcomponents/merging/circus.py | 4 ++--
 src/spikeinterface/sortingcomponents/merging/knn.py    | 2 +-
 src/spikeinterface/sortingcomponents/merging/lussac.py | 2 +-
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 270ec09ca4..7e1060e375 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -33,7 +33,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {"method": "lussac"},
+        "merging": {"method": "circus"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
@@ -133,7 +133,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 if verbose:
                     print("Motion correction activated (probe geometry compatible)")
                 motion_folder = sorter_output_folder / "motion"
-                params["motion_correction"].update({"folder": motion_folder})
+                params["motion_correction"].update({"folder": motion_folder, "overwrite" : True})
                 recording_f = correct_motion(recording_f, **params["motion_correction"])
         else:
             motion_folder = None
@@ -302,8 +302,9 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
             shutil.rmtree(sorting_folder)
 
         merging_params = params["merging"].copy()
+        merging_method = merging_params.get("method", None)
 
-        if len(merging_params) > 0:
+        if merging_method is not None:
             if params["motion_correction"] and motion_folder is not None:
                 from spikeinterface.preprocessing.motion import load_motion_info
 
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 84c9beee1e..91ee4f46cf 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -16,7 +16,7 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose": True,
+        "verbose": False,
         "remove_emtpy": True,
         "recursive": False,
         "censor_ms": 3,
@@ -68,7 +68,7 @@ def __init__(self, recording, sorting, kwargs):
     def _get_new_sorting(self):
         curation_kwargs = self.params.get("curation_kwargs", None)
         if curation_kwargs is not None:
-            merges = get_potential_auto_merge(self.analyzer, **curation_kwargs)
+            merges = get_potential_auto_merge(self.analyzer, **curation_kwargs, preset="lussac")
         else:
             merges = []
         if self.verbose:
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index 67ccb51dc9..222bc55072 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -24,7 +24,7 @@ class KNNMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose": True,
+        "verbose": False,
         "censor_ms": 3,
         "remove_emtpy": True,
         "recursive": True,
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index d8a056dd01..62a8fc2fc1 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -277,7 +277,7 @@ class LussacMerging(BaseMergingEngine):
 
     default_params = {
         "templates": None,
-        "verbose": True,
+        "verbose": False,
         "censor_ms": 3,
         "remove_emtpy": True,
         "recursive": False,

From a52dc642e816debe9441f874ca19ad7aef3b7d24 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 9 Jul 2024 09:38:16 +0000
Subject: [PATCH 128/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 7e1060e375..dc9d0e50e4 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -133,7 +133,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 if verbose:
                     print("Motion correction activated (probe geometry compatible)")
                 motion_folder = sorter_output_folder / "motion"
-                params["motion_correction"].update({"folder": motion_folder, "overwrite" : True})
+                params["motion_correction"].update({"folder": motion_folder, "overwrite": True})
                 recording_f = correct_motion(recording_f, **params["motion_correction"])
         else:
             motion_folder = None

From 50f6798f7052df392679cff159ef487d495c2617 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Tue, 9 Jul 2024 11:42:33 +0200
Subject: [PATCH 129/164] Adapt to new names

---
 src/spikeinterface/sortingcomponents/merging/circus.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 91ee4f46cf..28d702b484 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -23,9 +23,7 @@ class CircusMerging(BaseMergingEngine):
         "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
         "curation_kwargs": {
             "minimum_spikes": 50,
-            "corr_diff_thresh": 0.5,
             "maximum_distance_um": 50,
-            "template_diff_thresh": 0.5,
         },
         "temporal_splits_kwargs": {
             "minimum_spikes": 50,
@@ -68,7 +66,7 @@ def __init__(self, recording, sorting, kwargs):
     def _get_new_sorting(self):
         curation_kwargs = self.params.get("curation_kwargs", None)
         if curation_kwargs is not None:
-            merges = get_potential_auto_merge(self.analyzer, **curation_kwargs, preset="lussac")
+            merges = get_potential_auto_merge(self.analyzer, **curation_kwargs, preset="default")
         else:
             merges = []
         if self.verbose:

From ef9c25cb960eba08c2f5c61139c7018780170742 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 11 Jul 2024 18:37:45 +0200
Subject: [PATCH 130/164] Cleaning

---
 src/spikeinterface/sortingcomponents/merging/knn.py    | 3 ---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 3 ---
 2 files changed, 6 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
index 222bc55072..14288fd1ab 100644
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ b/src/spikeinterface/sortingcomponents/merging/knn.py
@@ -31,9 +31,6 @@ class KNNMerging(BaseMergingEngine):
         "knn_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um": 50,
-            "censored_period_ms": 0.3,
-            "refractory_period_ms": 1.0,
-            "corr_diff_thresh": 0.2,
             "k_nn": 5,
         },
     }
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 62a8fc2fc1..197edd6b94 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -285,9 +285,6 @@ class LussacMerging(BaseMergingEngine):
         "lussac_kwargs": {
             "minimum_spikes": 50,
             "maximum_distance_um": 50,
-            "censored_period_ms": 0.3,
-            "refractory_period_ms": 1.0,
-            "template_diff_thresh": 0.5,
         },
     }
 

From b86f3a1312362a714c33beec2d9168dcd1e67fb9 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 16 Jul 2024 09:07:47 +0200
Subject: [PATCH 131/164] WIP

---
 src/spikeinterface/curation/auto_merge.py | 276 ----------------------
 1 file changed, 276 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 9667d71779..856a012c29 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -128,51 +128,22 @@ def get_potential_auto_merge(
         Used to compute the refractory period violations aka "contamination".
     sigma_smooth_ms : float, default: 0.6
         Parameters to smooth the correlogram estimation.
-<<<<<<< HEAD
-    contamination_threshold : float, default: 0.2
-        Threshold for not taking in account a unit when it is too contaminated.
-    adaptative_window_threshold : : float, default: 0.5
-        Parameter to detect the window size in correlogram estimation.
-    censor_correlograms_ms : float, default: 0.15
-        The period to censor on the auto and cross-correlograms.
-    num_channels : int, default: 5
-        Number of channel to use for template similarity computation.
-    num_shift : int, default: 5
-        Number of shifts in samles to be explored for template similarity computation.
-    firing_contamination_balance : float, default: 2.5
-        Parameter to control the balance between firing rate and contamination in computing unit "quality score".
-    presence_distance_thresh : float, default: 100
-        Parameter to control how present two units should be simultaneously.
-=======
     adaptative_window_thresh : float, default: 0.5
         Parameter to detect the window size in correlogram estimation.
     censor_correlograms_ms : float, default: 0.15
         The period to censor on the auto and cross-correlograms.
     firing_contamination_balance : float, default: 2.5
         Parameter to control the balance between firing rate and contamination in computing unit "quality score".
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
     k_nn : int, default 5
         The number of neighbors to consider for every spike in the recording.
     knn_kwargs : dict, default None
         The dict of extra params to be passed to knn.
-<<<<<<< HEAD
-    presence_distance_kwargs : dict, default None
-        The dict of extra params to be passed to presence_distance.
-    extra_outputs : bool, default: False
-        If True, an additional dictionary (`outs`) with processed data is returned.
-    steps : None or list of str, default: None
-        which steps to run (gives flexibility to running just some steps)
-        If None all steps are done (except presence_distance).
-        Pontential steps : "min_spikes", "remove_contaminated", "unit_positions", "correlogram",
-        "template_similarity", "presence_distance", "cross_contamination", "knn", "check_increase_score"
-=======
     extra_outputs : bool, default: False
         If True, an additional dictionary (`outs`) with processed data is returned.
     steps : None or list of str, default: None
         Which steps to run, if no preset is used.
         Pontential steps : "num_spikes", "snr", "remove_contaminated", "unit_locations", "correlogram",
         "template_similarity", "presence_distance", "cross_contamination", "knn", "quality_score"
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
         Please check steps explanations above!
 
     Returns
@@ -201,80 +172,25 @@ def get_potential_auto_merge(
     #    * to far away one from each other
 
     all_steps = [
-<<<<<<< HEAD
-        "min_spikes",
-        "min_snr",
-        "remove_contaminated",
-        "unit_positions",
-=======
         "num_spikes",
         "snr",
         "remove_contaminated",
         "unit_locations",
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
         "correlogram",
         "template_similarity",
         "presence_distance",
         "knn",
         "cross_contamination",
-<<<<<<< HEAD
-        "check_increase_score",
-    ]
-
-=======
         "quality_score",
     ]
 
     if preset is not None and preset not in _possible_presets:
         raise ValueError(f"preset must be one of {_possible_presets}")
 
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
     if steps is None:
         if preset is None:
             if steps is None:
                 raise ValueError("You need to specify a preset or steps for the auto-merge function")
-<<<<<<< HEAD
-        elif preset == "default":
-            steps = [
-                "min_spikes",
-                "remove_contaminated",
-                "unit_positions",
-                "template_similarity",
-                "correlogram",
-                "check_increase_score",
-            ]
-        elif preset == "temporal_splits":
-            steps = [
-                "min_spikes",
-                "remove_contaminated",
-                "unit_positions",
-                "template_similarity",
-                "presence_distance",
-                "check_increase_score",
-            ]
-        elif preset == "lussac":
-            steps = [
-                "min_spikes",
-                "remove_contaminated",
-                "unit_positions",
-                "template_similarity",
-                "cross_contamination",
-                "check_increase_score",
-            ]
-        elif preset == "knn":
-            if not sorting_analyzer.has_extension("spike_locations"):
-                raise ValueError("knn preset requires spike_locations extension")
-            if not sorting_analyzer.has_extension("spike_amplitudes"):
-                raise ValueError("knn preset requires spike_amplitudes extension")
-            steps = [
-                "min_spikes",
-                "min_snr",
-                "remove_contaminated",
-                "unit_positions",
-                "knn",
-                "check_increase_score",
-            ]
-=======
         elif preset == "similarity_correlograms":
             steps = [
                 "num_spikes",
@@ -317,7 +233,6 @@ def get_potential_auto_merge(
             for ext in _required_extensions[step]:
                 if not sorting_analyzer.has_extension(ext):
                     raise ValueError(f"{step} requires {ext} extension")
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
 
     n = unit_ids.size
     pair_mask = np.triu(np.arange(n)) > 0
@@ -330,11 +245,7 @@ def get_potential_auto_merge(
         # STEP : remove units with too few spikes
         if step == "min_spikes":
             num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
-<<<<<<< HEAD
-            to_remove = num_spikes < minimum_spikes
-=======
             to_remove = num_spikes < min_spikes
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
 
@@ -347,11 +258,7 @@ def get_potential_auto_merge(
                 qm_ext = sorting_analyzer.get_extension("quality_metrics")
 
             snrs = qm_ext.get_data()["snr"].values
-<<<<<<< HEAD
-            to_remove = snrs < minimum_snr
-=======
             to_remove = snrs < min_snr
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
 
@@ -362,51 +269,23 @@ def get_potential_auto_merge(
             )
             nb_violations = np.array(list(nb_violations.values()))
             contaminations = np.array(list(contaminations.values()))
-<<<<<<< HEAD
-            to_remove = contaminations > contamination_threshold
-=======
             to_remove = contaminations > contamination_thresh
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
 
         # STEP : unit positions are estimated roughly with channel
-<<<<<<< HEAD
-        elif step == "unit_positions" in steps:
-            positions_ext = sorting_analyzer.get_extension("unit_locations")
-            if positions_ext is not None:
-                unit_locations = positions_ext.get_data()[:, :2]
-            else:
-                chan_loc = sorting_analyzer.get_channel_locations()
-                unit_max_chan = get_template_extremum_channel(
-                    sorting_analyzer, peak_sign=peak_sign, mode="extremum", outputs="index"
-                )
-                unit_max_chan = list(unit_max_chan.values())
-                unit_locations = chan_loc[unit_max_chan, :]
-
-            unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
-            pair_mask = pair_mask & (unit_distances <= maximum_distance_um)
-=======
         elif step == "unit_locations" in steps:
             location_ext = sorting_analyzer.get_extension("unit_locations")
             unit_locations = location_ext.get_data()[:, :2]
 
             unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
             pair_mask = pair_mask & (unit_distances <= max_distance_um)
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             outs["unit_distances"] = unit_distances
 
         # STEP : potential auto merge by correlogram
         elif step == "correlogram" in steps:
             correlograms_ext = sorting_analyzer.get_extension("correlograms")
-<<<<<<< HEAD
-            if correlograms_ext is not None:
-                correlograms, bins = correlograms_ext.get_data()
-            else:
-                correlograms, bins = compute_correlograms(sorting, window_ms=window_ms, bin_ms=bin_ms, method="numba")
-=======
             correlograms, bins = correlograms_ext.get_data()
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             mask = (bins[:-1] >= -censor_correlograms_ms) & (bins[:-1] < censor_correlograms_ms)
             correlograms[:, :, mask] = 0
             correlograms_smoothed = smooth_correlogram(correlograms, bins, sigma_smooth_ms=sigma_smooth_ms)
@@ -414,11 +293,7 @@ def get_potential_auto_merge(
             win_sizes = np.zeros(n, dtype=int)
             for unit_ind in range(n):
                 auto_corr = correlograms_smoothed[unit_ind, unit_ind, :]
-<<<<<<< HEAD
-                thresh = np.max(auto_corr) * adaptative_window_threshold
-=======
                 thresh = np.max(auto_corr) * adaptative_window_thresh
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
                 win_size = get_unit_adaptive_window(auto_corr, thresh)
                 win_sizes[unit_ind] = win_size
             correlogram_diff = compute_correlogram_diff(
@@ -438,49 +313,6 @@ def get_potential_auto_merge(
         # STEP : check if potential merge with CC also have template similarity
         elif step == "template_similarity" in steps:
             template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
-<<<<<<< HEAD
-            if template_similarity_ext is not None:
-                templates_similarity = template_similarity_ext.get_data()
-                templates_diff = 1 - templates_similarity
-
-            else:
-                templates_ext = sorting_analyzer.get_extension("templates")
-                assert (
-                    templates_ext is not None
-                ), "auto_merge with template_similarity requires a SortingAnalyzer with extension templates"
-                templates_array = templates_ext.get_data(outputs="numpy")
-
-                templates_diff = compute_templates_diff(
-                    sorting,
-                    templates_array,
-                    num_channels=num_channels,
-                    num_shift=num_shift,
-                    pair_mask=pair_mask,
-                    template_metric=template_metric,
-                    sparsity=sorting_analyzer.sparsity,
-                )
-            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
-            outs["templates_diff"] = templates_diff
-
-        # STEP : check the vicinity of the spikes
-        elif step == "knn" in steps:
-            if knn_kwargs is None:
-                knn_kwargs = dict()
-            pair_mask = get_pairs_via_nntree(sorting_analyzer, k_nn, pair_mask, **knn_kwargs)
-
-        # STEP : check how the rates overlap in times
-        elif step == "presence_distance" in steps:
-            presence_distance_kwargs = presence_distance_kwargs or dict()
-            num_samples = [
-                sorting_analyzer.get_num_samples(segment_index) for segment_index in range(sorting.get_num_segments())
-            ]
-            presence_distances = compute_presence_distance(
-                sorting, pair_mask, num_samples=num_samples, **presence_distance_kwargs
-            )
-            pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
-            outs["presence_distances"] = presence_distances
-
-=======
             templates_similarity = template_similarity_ext.get_data()
             templates_diff = 1 - templates_similarity
             pair_mask = pair_mask & (templates_diff < template_diff_thresh)
@@ -504,26 +336,17 @@ def get_potential_auto_merge(
             pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
             outs["presence_distances"] = presence_distances
 
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
         # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
             refractory = (censored_period_ms, refractory_period_ms)
             CC, p_values = compute_cross_contaminations(
-<<<<<<< HEAD
-                sorting_analyzer, pair_mask, CC_threshold, refractory, contaminations
-=======
                 sorting_analyzer, pair_mask, cc_thresh, refractory, contaminations
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             )
             pair_mask = pair_mask & (p_values > p_value)
             outs["cross_contaminations"] = CC, p_values
 
         # STEP : validate the potential merges with CC increase the contamination quality metrics
-<<<<<<< HEAD
-        elif step == "check_increase_score" in steps:
-=======
         elif step == "quality_score" in steps:
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             pair_mask, pairs_decreased_score = check_improve_contaminations_score(
                 sorting_analyzer,
                 pair_mask,
@@ -730,66 +553,7 @@ def get_unit_adaptive_window(auto_corr: np.ndarray, threshold: float):
     return win_size
 
 
-<<<<<<< HEAD
-def compute_cross_contaminations(analyzer, pair_mask, CC_threshold, refractory_period, contaminations=None):
-    """
-    Looks at a sorting analyzer, and returns statistical tests for cross_contaminations
-
-    Parameters
-    ----------
-    analyzer : SortingAnalyzer
-        The analyzer to look at
-    CC_treshold : float, default: 0.1
-        The threshold on the cross-contamination.
-        Any pair above this threshold will not be considered.
-    refractory_period : array/list/tuple of 2 floats
-        (censored_period_ms, refractory_period_ms)
-    contaminations : contaminations of the units, if already precomputed
-
-    """
-    from spikeinterface.sortingcomponents.merging.lussac import estimate_cross_contamination
-
-    sorting = analyzer.sorting
-    unit_ids = sorting.unit_ids
-    n = len(unit_ids)
-    sf = analyzer.sampling_frequency
-    n_frames = analyzer.get_total_samples()
-
-    if pair_mask is None:
-        pair_mask = np.ones((n, n), dtype="bool")
-
-    CC = np.zeros((n, n), dtype=np.float32)
-    p_values = np.zeros((n, n), dtype=np.float32)
-
-    for unit_ind1 in range(len(unit_ids)):
-
-        unit_id1 = unit_ids[unit_ind1]
-        spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
-
-        for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
-            if not pair_mask[unit_ind1, unit_ind2]:
-                continue
-
-            unit_id2 = unit_ids[unit_ind2]
-            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
-            # Compuyting the cross-contamination difference
-            if contaminations is not None:
-                C1 = contaminations[unit_ind1]
-            else:
-                C1 = None
-            CC[unit_ind1, unit_ind2], p_values[unit_ind1, unit_ind2] = estimate_cross_contamination(
-                spike_train1, spike_train2, sf, n_frames, refractory_period, limit=CC_threshold, C1=C1
-            )
-
-    return CC, p_values
-
-
-def compute_templates_diff(
-    sorting, templates_array, num_channels=5, num_shift=5, pair_mask=None, template_metric="l1", sparsity=None
-):
-=======
 def compute_cross_contaminations(analyzer, pair_mask, cc_thresh, refractory_period, contaminations=None):
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
     """
     Looks at a sorting analyzer, and returns statistical tests for cross_contaminations
 
@@ -817,19 +581,12 @@ def compute_cross_contaminations(analyzer, pair_mask, cc_thresh, refractory_peri
     CC = np.zeros((n, n), dtype=np.float32)
     p_values = np.zeros((n, n), dtype=np.float32)
 
-<<<<<<< HEAD
-    templates_diff = np.full((n, n), np.nan, dtype="float64")
-    all_shifts = range(-num_shift, num_shift + 1)
-    for unit_ind1 in range(n):
-        for unit_ind2 in range(unit_ind1 + 1, n):
-=======
     for unit_ind1 in range(len(unit_ids)):
 
         unit_id1 = unit_ids[unit_ind1]
         spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
 
         for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
             if not pair_mask[unit_ind1, unit_ind2]:
                 continue
 
@@ -839,45 +596,12 @@ def compute_cross_contaminations(analyzer, pair_mask, cc_thresh, refractory_peri
             if contaminations is not None:
                 C1 = contaminations[unit_ind1]
             else:
-<<<<<<< HEAD
-                chan_inds = np.flatnonzero(sparsity_mask[unit_ind1] * sparsity_mask[unit_ind2])
-
-            if len(chan_inds) > 0:
-                template1 = template1[:, chan_inds]
-                template2 = template2[:, chan_inds]
-
-                num_samples = template1.shape[0]
-                if template_metric == "l1":
-                    norm = np.sum(np.abs(template1)) + np.sum(np.abs(template2))
-                elif template_metric == "l2":
-                    norm = np.sum(template1**2) + np.sum(template2**2)
-                elif template_metric == "cosine":
-                    norm = np.linalg.norm(template1) * np.linalg.norm(template2)
-                all_shift_diff = []
-                for shift in all_shifts:
-                    temp1 = template1[num_shift : num_samples - num_shift, :]
-                    temp2 = template2[num_shift + shift : num_samples - num_shift + shift, :]
-                    if template_metric == "l1":
-                        d = np.sum(np.abs(temp1 - temp2)) / norm
-                    elif template_metric == "l2":
-                        d = np.linalg.norm(temp1 - temp2) / norm
-                    elif template_metric == "cosine":
-                        d = 1 - np.sum(temp1 * temp2) / norm
-                    all_shift_diff.append(d)
-            else:
-                all_shift_diff = [1] * len(all_shifts)
-
-            templates_diff[unit_ind1, unit_ind2] = np.min(all_shift_diff)
-
-    return templates_diff
-=======
                 C1 = None
             CC[unit_ind1, unit_ind2], p_values[unit_ind1, unit_ind2] = estimate_cross_contamination(
                 spike_train1, spike_train2, sf, n_frames, refractory_period, limit=cc_thresh, C1=C1
             )
 
     return CC, p_values
->>>>>>> 7562b247bd5d3dc2c6e7c8723ab104beefbef1ab
 
 
 def check_improve_contaminations_score(

From f906059d5b74f82f00e30382d23dafba239a8f1a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 16 Jul 2024 09:11:33 +0200
Subject: [PATCH 132/164] Sync with main

---
 .../curation/merge_temporal_splits.py         | 113 --------
 .../sortingcomponents/merging/lussac.py       | 261 ------------------
 2 files changed, 374 deletions(-)
 delete mode 100644 src/spikeinterface/curation/merge_temporal_splits.py

diff --git a/src/spikeinterface/curation/merge_temporal_splits.py b/src/spikeinterface/curation/merge_temporal_splits.py
deleted file mode 100644
index 44b189abe7..0000000000
--- a/src/spikeinterface/curation/merge_temporal_splits.py
+++ /dev/null
@@ -1,113 +0,0 @@
-from __future__ import annotations
-import numpy as np
-
-
-def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None, num_samples=None):
-    """
-    Compute the presence distance between two units.
-
-    The presence distance is defined as the Wasserstein distance between the two histograms of
-    the firing activity over time.
-
-    Parameters
-    ----------
-    sorting : Sorting
-        The sorting object.
-    unit1 : int or str
-        The id of the first unit.
-    unit2 : int or str
-        The id of the second unit.
-    bin_duration_s : float
-        The duration of the bin in seconds.
-    bins : array-like
-        The bins used to compute the firing rate.
-    num_samples : list | int | None, default: None
-        The number of samples for each segment. Required if the sorting doesn't have a recording
-        attached.
-
-    Returns
-    -------
-    d : float
-        The presence distance between the two units.
-    """
-    import scipy
-
-    distances = []
-    if num_samples is not None:
-        if isinstance(num_samples, int):
-            num_samples = [num_samples]
-
-    if not sorting.has_recording():
-        if num_samples is None:
-            raise ValueError("num_samples must be provided if sorting has no recording")
-        if len(num_samples) != sorting.get_num_segments():
-            raise ValueError("num_samples must have the same length as the number of segments")
-
-    for segment_index in range(sorting.get_num_segments()):
-        if bins is None:
-            bin_size = bin_duration_s * sorting.sampling_frequency
-            if sorting.has_recording():
-                ns = sorting.get_num_samples(segment_index)
-            else:
-                ns = num_samples[segment_index]
-            bins = np.arange(0, ns, bin_size)
-
-        st1 = sorting.get_unit_spike_train(unit_id=unit1)
-        st2 = sorting.get_unit_spike_train(unit_id=unit2)
-
-        h1, _ = np.histogram(st1, bins)
-        h1 = h1.astype(float)
-
-        h2, _ = np.histogram(st2, bins)
-        h2 = h2.astype(float)
-
-        xaxis = bins[1:] / sorting.sampling_frequency
-        d = scipy.stats.wasserstein_distance(xaxis, xaxis, h1, h2)
-        distances.append(d)
-
-    return np.mean(d)
-
-
-def compute_presence_distance(sorting, pair_mask, num_samples=None, **presence_distance_kwargs):
-    """
-    Get the potential drift-related merges based on similarity and presence completeness.
-
-    Parameters
-    ----------
-    sorting : Sorting
-        The sorting object
-    pair_mask : None or boolean array
-        A bool matrix of size (num_units, num_units) to select
-        which pair to compute.
-    num_samples : list | int | None, default: None
-        The number of samples for each segment. Required if the sorting doesn't have a recording
-        attached.
-    presence_distance_threshold : float
-        The presence distance threshold used to consider two units as similar
-    presence_distance_kwargs : A dictionary of kwargs to be passed to compute_presence_distance().
-
-    Returns
-    -------
-    potential_merges : list
-        The list of potential merges
-
-    """
-
-    unit_ids = sorting.unit_ids
-    n = len(unit_ids)
-
-    if pair_mask is None:
-        pair_mask = np.ones((n, n), dtype="bool")
-
-    presence_distances = np.ones((sorting.get_num_units(), sorting.get_num_units()))
-
-    for unit_ind1 in range(n):
-        for unit_ind2 in range(unit_ind1 + 1, n):
-            if not pair_mask[unit_ind1, unit_ind2]:
-                continue
-            unit1 = unit_ids[unit_ind1]
-            unit2 = unit_ids[unit_ind2]
-            d = presence_distance(sorting, unit1, unit2, num_samples=num_samples, **presence_distance_kwargs)
-            presence_distances[unit_ind1, unit_ind2] = d
-
-    return presence_distances
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 197edd6b94..17876540c3 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -2,13 +2,6 @@
 import numpy as np
 import math
 
-try:
-    import numba
-
-    HAVE_NUMBA = True
-except ImportError:
-    HAVE_NUMBA = False
-
 from .main import BaseMergingEngine
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.analyzer_extension_core import ComputeTemplates
@@ -16,260 +9,6 @@
 from spikeinterface.curation.curation_tools import resolve_merging_graph
 from spikeinterface.core.sorting_tools import apply_merges_to_sorting
 
-
-def binom_sf(x: int, n: float, p: float) -> float:
-    """
-    Computes the survival function (sf = 1 - cdf) of the binomial distribution.
-
-    Parameters
-    ----------
-    x : int
-        The number of successes.
-    n : float
-        The number of trials.
-    p : float
-        The probability of success.
-
-    Returns
-    -------
-    sf : float
-        The survival function of the binomial distribution.
-    """
-
-    import scipy
-
-    n_array = np.arange(math.floor(n - 2), math.ceil(n + 3), 1)
-    n_array = n_array[n_array >= 0]
-
-    res = [scipy.stats.binom.sf(x, n_, p) for n_ in n_array]
-    f = scipy.interpolate.interp1d(n_array, res, kind="quadratic")
-
-    return f(n)
-
-
-if HAVE_NUMBA:
-
-    @numba.jit((numba.float32,), nopython=True, nogil=True, cache=True)
-    def _get_border_probabilities(max_time) -> tuple[int, int, float, float]:
-        """
-        Computes the integer borders, and the probability of 2 spikes distant by this border to be closer than max_time.
-
-        Parameters
-        ----------
-        max_time : float
-            The maximum time between 2 spikes to be considered as a coincidence.
-
-        Returns
-        -------
-        border_low : int
-            The lower border.
-        border_high : int
-            The higher border.
-        p_low : float
-            The probability of 2 spikes distant by the lower border to be closer than max_time.
-        p_high : float
-            The probability of 2 spikes distant by the higher border to be closer than max_time.
-        """
-
-        border_high = math.ceil(max_time)
-        border_low = math.floor(max_time)
-        p_high = 0.5 * (max_time - border_high + 1) ** 2
-        p_low = 0.5 * (1 - (max_time - border_low) ** 2) + (max_time - border_low)
-
-        if border_low == 0:
-            p_low -= 0.5 * (-max_time + 1) ** 2
-
-        return border_low, border_high, p_low, p_high
-
-    @numba.jit((numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
-    def compute_nb_violations(spike_train, max_time) -> float:
-        """
-        Computes the number of refractory period violations in a spike train.
-
-        Parameters
-        ----------
-        spike_train : array[int64] (n_spikes)
-            The spike train to compute the number of violations for.
-        max_time : float32
-            The maximum time to consider for violations (in number of samples).
-
-        Returns
-        -------
-        n_violations : float
-            The number of spike pairs that violate the refractory period.
-        """
-
-        if max_time <= 0.0:
-            return 0.0
-
-        border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
-        n_violations = 0
-        n_violations_low = 0
-        n_violations_high = 0
-
-        for i in range(len(spike_train) - 1):
-            for j in range(i + 1, len(spike_train)):
-                diff = spike_train[j] - spike_train[i]
-
-                if diff > border_high:
-                    break
-                if diff == border_high:
-                    n_violations_high += 1
-                elif diff == border_low:
-                    n_violations_low += 1
-                else:
-                    n_violations += 1
-
-        return n_violations + p_high * n_violations_high + p_low * n_violations_low
-
-    @numba.jit((numba.int64[:], numba.int64[:], numba.float32), nopython=True, nogil=True, cache=True)
-    def compute_nb_coincidence(spike_train1, spike_train2, max_time) -> float:
-        """
-        Computes the number of coincident spikes between two spike trains.
-
-        Parameters
-        ----------
-        spike_train1 : array[int64] (n_spikes1)
-            The spike train of the first unit.
-        spike_train2 : array[int64] (n_spikes2)
-            The spike train of the second unit.
-        max_time : float32
-            The maximum time to consider for coincidence (in number samples).
-
-        Returns
-        -------
-        n_coincidence : float
-            The number of coincident spikes.
-        """
-
-        if max_time <= 0:
-            return 0.0
-
-        border_low, border_high, p_low, p_high = _get_border_probabilities(max_time)
-        n_coincident = 0
-        n_coincident_low = 0
-        n_coincident_high = 0
-
-        start_j = 0
-        for i in range(len(spike_train1)):
-            for j in range(start_j, len(spike_train2)):
-                diff = spike_train1[i] - spike_train2[j]
-
-                if diff > border_high:
-                    start_j += 1
-                    continue
-                if diff < -border_high:
-                    break
-                if abs(diff) == border_high:
-                    n_coincident_high += 1
-                elif abs(diff) == border_low:
-                    n_coincident_low += 1
-                else:
-                    n_coincident += 1
-
-        return n_coincident + p_high * n_coincident_high + p_low * n_coincident_low
-
-
-def estimate_contamination(spike_train: np.ndarray, sf: float, T: int, refractory_period: tuple[float, float]) -> float:
-    """
-    Estimates the contamination of a spike train by looking at the number of refractory period violations.
-
-    Parameters
-    ----------
-    spike_train : np.ndarray
-        The unit's spike train.
-    sf : float
-        The sampling frequency of the spike train.
-    T : int
-        The duration of the spike train in samples.
-    refractory_period : tuple[float, float]
-        The censored and refractory period (t_c, t_r) used (in ms).
-
-    Returns
-    -------
-    estimated_contamination : float
-        The estimated contamination between 0 and 1.
-    """
-
-    t_c = refractory_period[0] * 1e-3 * sf
-    t_r = refractory_period[1] * 1e-3 * sf
-    n_v = compute_nb_violations(spike_train.astype(np.int64), t_r)
-
-    N = len(spike_train)
-    D = 1 - n_v * (T - 2 * N * t_c) / (N**2 * (t_r - t_c))
-    contamination = 1.0 if D < 0 else 1 - math.sqrt(D)
-
-    return contamination
-
-
-def estimate_cross_contamination(
-    spike_train1: np.ndarray,
-    spike_train2: np.ndarray,
-    sf: float,
-    T: int,
-    refractory_period: tuple[float, float],
-    limit: float | None = None,
-    C1: float | None = None,
-) -> tuple[float, float] | float:
-    """
-    Estimates the cross-contamination of the second spike train with the neuron of the first spike train.
-    Also performs a statistical test to check if the cross-contamination is significantly higher than a given limit.
-
-    Parameters
-    ----------
-    spike_train1 : np.ndarray
-        The spike train of the first unit.
-    spike_train2 : np.ndarray
-        The spike train of the second unit.
-    sf : float
-        The sampling frequency (in Hz).
-    T : int
-        The duration of the recording (in samples).
-    refractory_period : tuple[float, float]
-        The censored and refractory period (t_c, t_r) used (in ms).
-    limit : float, optional
-        The higher limit of cross-contamination for the statistical test.
-    C1 : float, optional
-        The contamination estimate of the first spike train.
-
-    Returns
-    -------
-    (estimated_cross_cont, p_value) : tuple[float, float] if limit is not None
-        estimated_cross_cont : float if limit is None
-            The estimation of cross-contamination.
-        p_value : float
-            The p-value of the statistical test if the limit is given.
-    """
-    spike_train1 = spike_train1.astype(np.int64, copy=False)
-    spike_train2 = spike_train2.astype(np.int64, copy=False)
-
-    N1 = float(len(spike_train1))
-    N2 = float(len(spike_train2))
-    if C1 is None:
-        C1 = estimate_contamination(spike_train1, sf, T, refractory_period)
-
-    t_c = int(round(refractory_period[0] * 1e-3 * sf))
-    t_r = int(round(refractory_period[1] * 1e-3 * sf))
-    n_violations = compute_nb_coincidence(spike_train1, spike_train2, t_r) - compute_nb_coincidence(
-        spike_train1, spike_train2, t_c
-    )
-
-    estimation = 1 - ((n_violations * T) / (2 * N1 * N2 * t_r) - 1.0) / (C1 - 1.0) if C1 != 1.0 else -np.inf
-    if limit is None:
-        return estimation
-
-    # n and p for the binomial law for the number of coincidence (under the hypothesis of cross-contamination = limit).
-    n = N1 * N2 * ((1 - C1) * limit + C1)
-    p = 2 * t_r / T
-    p_value = binom_sf(int(n_violations - 1), n, p)
-    if np.isnan(p_value):  # Should be unreachable
-        raise ValueError(
-            f"Could not compute p-value for cross-contamination:\n\tn_violations = {n_violations}\n\tn = {n}\n\tp = {p}"
-        )
-
-    return estimation, p_value
-
-
 class LussacMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric

From 2678d54b34c86144fdcce8b745f74e9fb6cf1823 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 16 Jul 2024 07:11:59 +0000
Subject: [PATCH 133/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 17876540c3..b75ac1d7a5 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -9,6 +9,7 @@
 from spikeinterface.curation.curation_tools import resolve_merging_graph
 from spikeinterface.core.sorting_tools import apply_merges_to_sorting
 
+
 class LussacMerging(BaseMergingEngine):
     """
     Meta merging inspired from the Lussac metric

From 4dccd5119d56e803f3cf78c094a9454443e9f094 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Tue, 16 Jul 2024 09:22:30 +0200
Subject: [PATCH 134/164] Sync with main

---
 src/spikeinterface/sortingcomponents/tools.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/tools.py b/src/spikeinterface/sortingcomponents/tools.py
index bc930123d8..facefac4c5 100644
--- a/src/spikeinterface/sortingcomponents/tools.py
+++ b/src/spikeinterface/sortingcomponents/tools.py
@@ -80,8 +80,8 @@ def get_prototype_spike(recording, peaks, ms_before=0.5, ms_after=0.5, nb_peaks=
     waveforms = extract_waveform_at_max_channel(
         recording, few_peaks, ms_before=ms_before, ms_after=ms_after, **job_kwargs
     )
-    with np.errstate(divide="ignore"):
-        prototype = np.nanmedian(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        prototype = np.median(waveforms[:, :, 0] / (np.abs(waveforms[:, nbefore, 0][:, np.newaxis])), axis=0)
     return prototype
 
 

From f3c2d7bb9c727fb522589a64eb23affb6077fef3 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 10:09:12 +0200
Subject: [PATCH 135/164] WIP

---
 src/spikeinterface/curation/auto_merge.py | 379 ++++++----------------
 1 file changed, 96 insertions(+), 283 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index e00f77df96..c66025f346 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -25,28 +25,42 @@
 _required_extensions = {
     "unit_locations": ["unit_locations"],
     "correlogram": ["correlograms"],
+    "min_snr" : ["noise_levels", "templates"],
     "template_similarity": ["template_similarity"],
     "knn": ["spike_locations", "spike_amplitudes"],
 }
 
 
-
-
-def get_auto_merges(
+def auto_merges(
     sorting_analyzer: SortingAnalyzer,
     preset: str | None = "similarity_correlograms",
-    num_spikes_kwargs={"min_spikes" : 10},
+    resolve_graph: bool = False,
+    num_spikes_kwargs={"min_spikes" : 100},
     snr_kwargs={"min_snr" : 2},
-    remove_contaminated_kwargs=None,
-    unit_locations_kwargs=None,
-    correlogram_kwargs=None,
-    template_similarity_kwargs=None,
-    presence_distance_kwargs=None,
-    knn_kwargs=None,
-    cross_contamination_kwargs=None,
-    quality_score_kwargs=None,
-    compute_needed_extensions=True
-)
+    remove_contaminated_kwargs={"contamination_thresh" : 0.2,
+                                "refractory_period_ms" : 1.0,
+                                "censored_period_ms" : 0.3},
+    unit_locations_kwargs={"max_distance_um" : 150},
+    correlogram_kwargs={"corr_diff_thresh" : 0.16, 
+                        "censor_correlograms_ms" : 0.15, 
+                        "sigma_smooth_ms" : 0.6,
+                        "adaptative_window_thresh" : 0.5},
+    template_similarity_kwargs={"template_diff_thresh" : 0.25},
+    presence_distance_kwargs={"presence_distance_thresh" : 100},
+    knn_kwargs={"k_nn" : 10},
+    cross_contamination_kwargs={"cc_thresh" : 0.1,
+                                "p_value" : 0.2,
+                                "refractory_period_ms" : 1.0,
+                                "censored_period_ms" : 0.3},
+    quality_score_kwargs={"firing_contamination_balance" : 2.5,
+                          "refractory_period_ms" : 1.0,
+                          "censored_period_ms" : 0.3},
+    compute_needed_extensions=True,
+    extra_outputs: bool = False,
+    steps: list[str] | None = None,
+    **job_kwargs
+) -> list[tuple[int | str, int | str]] | Tuple[tuple[int | str, int | str], dict]:
+    
     """
     Algorithm to find and check potential merges between units.
 
@@ -93,43 +107,7 @@ def get_auto_merges(
         If `preset` is None, you can specify the steps manually with the `steps` parameter.
     resolve_graph : bool, default: False
         If True, the function resolves the potential unit pairs to be merged into multiple-unit merges.
-    min_spikes : int, default: 100
-        Minimum number of spikes for each unit to consider a potential merge.
-        Enough spikes are needed to estimate the correlogram
-    min_snr : float, default 2
-        Minimum Signal to Noise ratio for templates to be considered while merging
-    max_distance_um : float, default: 150
-        Maximum distance between units for considering a merge
-    corr_diff_thresh : float, default: 0.16
-        The threshold on the "correlogram distance metric" for considering a merge.
-        It needs to be between 0 and 1
-    template_diff_thresh : float, default: 0.25
-        The threshold on the "template distance metric" for considering a merge.
-        It needs to be between 0 and 1
-    contamination_thresh : float, default: 0.2
-        Threshold for not taking in account a unit when it is too contaminated.
-    presence_distance_thresh : float, default: 100
-        Parameter to control how present two units should be simultaneously.
-    p_value : float, default: 0.2
-        The p-value threshold for the cross-contamination test.
-    cc_thresh : float, default: 0.1
-        The threshold on the cross-contamination for considering a merge.
-    censored_period_ms : float, default: 0.3
-        Used to compute the refractory period violations aka "contamination".
-    refractory_period_ms : float, default: 1
-        Used to compute the refractory period violations aka "contamination".
-    sigma_smooth_ms : float, default: 0.6
-        Parameters to smooth the correlogram estimation.
-    adaptative_window_thresh : float, default: 0.5
-        Parameter to detect the window size in correlogram estimation.
-    censor_correlograms_ms : float, default: 0.15
-        The period to censor on the auto and cross-correlograms.
-    firing_contamination_balance : float, default: 2.5
-        Parameter to control the balance between firing rate and contamination in computing unit "quality score".
-    k_nn : int, default 5
-        The number of neighbors to consider for every spike in the recording.
-    knn_kwargs : dict, default None
-        The dict of extra params to be passed to knn.
+
     extra_outputs : bool, default: False
         If True, an additional dictionary (`outs`) with processed data is returned.
     steps : None or list of str, default: None
@@ -221,10 +199,16 @@ def get_auto_merges(
             ]
 
     for step in steps:
-        if step in _required_extensions and not compute_needed_extensions:
+        if step in _required_extensions:
             for ext in _required_extensions[step]:
                 if not sorting_analyzer.has_extension(ext):
-                    raise ValueError(f"{step} requires {ext} extension")
+                    if not compute_needed_extensions:
+                        raise ValueError(f"{step} requires {ext} extension")
+                    else:
+                        params = eval(f"{step}_kwargs")
+                        print("toto", params, step, ext)
+                        sorting_analyzer.compute(ext, **params, **job_kwargs)
+            
 
     n = unit_ids.size
     pair_mask = np.triu(np.arange(n)) > 0
@@ -237,33 +221,38 @@ def get_auto_merges(
         # STEP : remove units with too few spikes
         if step == "num_spikes":
             num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
-            to_remove = num_spikes < num_spikes_kwargs['min_spikes']
+            to_remove = num_spikes < num_spikes_kwargs["min_spikes"]
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
+            outs["num_spikes"] = to_remove
 
         # STEP : remove units with too small SNR
         elif step == "snr":
             qm_ext = sorting_analyzer.get_extension("quality_metrics")
             if qm_ext is None:
-                sorting_analyzer.compute("noise_levels")
-                sorting_analyzer.compute("quality_metrics", metric_names=["snr"])
+                sorting_analyzer.compute(["noise_levels", "random_spikes", "templates"], **job_kwargs)
+                sorting_analyzer.compute("quality_metrics", metric_names=["snr"], **job_kwargs)
                 qm_ext = sorting_analyzer.get_extension("quality_metrics")
 
             snrs = qm_ext.get_data()["snr"].values
             to_remove = snrs < snr_kwargs["min_snr"]
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
+            outs["snr"] = to_remove
 
         # STEP : remove contaminated auto corr
         elif step == "remove_contaminated":
             contaminations, nb_violations = compute_refrac_period_violations(
-                sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
+                sorting_analyzer, 
+                refractory_period_ms=remove_contaminated_kwargs["refractory_period_ms"], 
+                censored_period_ms=remove_contaminated_kwargs["censored_period_ms"]
             )
             nb_violations = np.array(list(nb_violations.values()))
             contaminations = np.array(list(contaminations.values()))
-            to_remove = contaminations > contamination_thresh
+            to_remove = contaminations > remove_contaminated_kwargs["contamination_thresh"]
             pair_mask[to_remove, :] = False
             pair_mask[:, to_remove] = False
+            outs["remove_contaminated"] = to_remove
 
         # STEP : unit positions are estimated roughly with channel
         elif step == "unit_locations" in steps:
@@ -271,21 +260,23 @@ def get_auto_merges(
             unit_locations = location_ext.get_data()[:, :2]
 
             unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
-            pair_mask = pair_mask & (unit_distances <= max_distance_um)
+            pair_mask = pair_mask & (unit_distances <= unit_locations_kwargs["max_distance_um"])
             outs["unit_distances"] = unit_distances
 
         # STEP : potential auto merge by correlogram
         elif step == "correlogram" in steps:
             correlograms_ext = sorting_analyzer.get_extension("correlograms")
             correlograms, bins = correlograms_ext.get_data()
-            mask = (bins[:-1] >= -censor_correlograms_ms) & (bins[:-1] < censor_correlograms_ms)
+            censor_ms = correlogram_kwargs["censor_correlograms_ms"]
+            sigma_smooth_ms = correlogram_kwargs["sigma_smooth_ms"]
+            mask = (bins[:-1] >= -censor_ms) & (bins[:-1] < censor_ms)
             correlograms[:, :, mask] = 0
             correlograms_smoothed = smooth_correlogram(correlograms, bins, sigma_smooth_ms=sigma_smooth_ms)
             # find correlogram window for each units
             win_sizes = np.zeros(n, dtype=int)
             for unit_ind in range(n):
                 auto_corr = correlograms_smoothed[unit_ind, unit_ind, :]
-                thresh = np.max(auto_corr) * adaptative_window_thresh
+                thresh = np.max(auto_corr) * correlogram_kwargs["adaptative_window_thresh"]
                 win_size = get_unit_adaptive_window(auto_corr, thresh)
                 win_sizes[unit_ind] = win_size
             correlogram_diff = compute_correlogram_diff(
@@ -295,7 +286,7 @@ def get_auto_merges(
                 pair_mask=pair_mask,
             )
             # print(correlogram_diff)
-            pair_mask = pair_mask & (correlogram_diff < corr_diff_thresh)
+            pair_mask = pair_mask & (correlogram_diff < correlogram_kwargs["corr_diff_thresh"])
             outs["correlograms"] = correlograms
             outs["bins"] = bins
             outs["correlograms_smoothed"] = correlograms_smoothed
@@ -307,18 +298,17 @@ def get_auto_merges(
             template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
             templates_similarity = template_similarity_ext.get_data()
             templates_diff = 1 - templates_similarity
-            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
+            pair_mask = pair_mask & (templates_diff < template_similarity_kwargs["template_diff_thresh"])
             outs["templates_diff"] = templates_diff
 
         # STEP : check the vicinity of the spikes
         elif step == "knn" in steps:
-            if knn_kwargs is None:
-                knn_kwargs = dict()
-            pair_mask = get_pairs_via_nntree(sorting_analyzer, k_nn, pair_mask, **knn_kwargs)
+            pair_mask = get_pairs_via_nntree(sorting_analyzer, **knn_kwargs, pair_mask=pair_mask, job_kwargs=job_kwargs)
 
         # STEP : check how the rates overlap in times
         elif step == "presence_distance" in steps:
-            presence_distance_kwargs = presence_distance_kwargs or dict()
+            presence_distance_kwargs = presence_distance_kwargs.copy()
+            presence_distance_thresh = presence_distance_kwargs.pop("presence_distance_thresh")
             num_samples = [
                 sorting_analyzer.get_num_samples(segment_index) for segment_index in range(sorting.get_num_segments())
             ]
@@ -330,11 +320,12 @@ def get_auto_merges(
 
         # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
-            refractory = (censored_period_ms, refractory_period_ms)
+            refractory = (cross_contamination_kwargs["censored_period_ms"], 
+                          cross_contamination_kwargs["refractory_period_ms"])
             CC, p_values = compute_cross_contaminations(
-                sorting_analyzer, pair_mask, cc_thresh, refractory, contaminations
+                sorting_analyzer, pair_mask, cross_contamination_kwargs["cc_thresh"], refractory, contaminations
             )
-            pair_mask = pair_mask & (p_values > p_value)
+            pair_mask = pair_mask & (p_values > cross_contamination_kwargs["p_value"])
             outs["cross_contaminations"] = CC, p_values
 
         # STEP : validate the potential merges with CC increase the contamination quality metrics
@@ -343,9 +334,9 @@ def get_auto_merges(
                 sorting_analyzer,
                 pair_mask,
                 contaminations,
-                firing_contamination_balance,
-                refractory_period_ms,
-                censored_period_ms,
+                quality_score_kwargs["firing_contamination_balance"],
+                quality_score_kwargs["refractory_period_ms"],
+                quality_score_kwargs["censored_period_ms"],
             )
             outs["pairs_decreased_score"] = pairs_decreased_score
 
@@ -496,216 +487,38 @@ def get_potential_auto_merge(
     done by Aurelien Wyngaard and Victor Llobet.
     https://github.com/BarbourLab/lussac/blob/v1.0.0/postprocessing/merge_units.py
     """
-    import scipy
-
-    sorting = sorting_analyzer.sorting
-    unit_ids = sorting.unit_ids
-
-    # to get fast computation we will not analyse pairs when:
-    #    * not enough spikes for one of theses
-    #    * auto correlogram is contaminated
-    #    * to far away one from each other
-
-    all_steps = [
-        "num_spikes",
-        "snr",
-        "remove_contaminated",
-        "unit_locations",
-        "correlogram",
-        "template_similarity",
-        "presence_distance",
-        "knn",
-        "cross_contamination",
-        "quality_score",
-    ]
-
-    if preset is not None and preset not in _possible_presets:
-        raise ValueError(f"preset must be one of {_possible_presets}")
-
-    if steps is None:
-        if preset is None:
-            if steps is None:
-                raise ValueError("You need to specify a preset or steps for the auto-merge function")
-        elif preset == "similarity_correlograms":
-            steps = [
-                "num_spikes",
-                "remove_contaminated",
-                "unit_locations",
-                "template_similarity",
-                "correlogram",
-                "quality_score",
-            ]
-        elif preset == "temporal_splits":
-            steps = [
-                "num_spikes",
-                "remove_contaminated",
-                "unit_locations",
-                "template_similarity",
-                "presence_distance",
-                "quality_score",
-            ]
-        elif preset == "x_contaminations":
-            steps = [
-                "num_spikes",
-                "remove_contaminated",
-                "unit_locations",
-                "template_similarity",
-                "cross_contamination",
-                "quality_score",
-            ]
-        elif preset == "feature_neighbors":
-            steps = [
-                "num_spikes",
-                "snr",
-                "remove_contaminated",
-                "unit_locations",
-                "knn",
-                "quality_score",
-            ]
-
-    for step in steps:
-        if step in _required_extensions:
-            for ext in _required_extensions[step]:
-                if not sorting_analyzer.has_extension(ext):
-                    raise ValueError(f"{step} requires {ext} extension")
-
-    n = unit_ids.size
-    pair_mask = np.triu(np.arange(n)) > 0
-    outs = dict()
-
-    for step in steps:
-
-        assert step in all_steps, f"{step} is not a valid step"
-
-        # STEP : remove units with too few spikes
-        if step == "num_spikes":
-            num_spikes = sorting.count_num_spikes_per_unit(outputs="array")
-            to_remove = num_spikes < min_spikes
-            pair_mask[to_remove, :] = False
-            pair_mask[:, to_remove] = False
-
-        # STEP : remove units with too small SNR
-        elif step == "snr":
-            qm_ext = sorting_analyzer.get_extension("quality_metrics")
-            if qm_ext is None:
-                sorting_analyzer.compute("noise_levels")
-                sorting_analyzer.compute("quality_metrics", metric_names=["snr"])
-                qm_ext = sorting_analyzer.get_extension("quality_metrics")
-
-            snrs = qm_ext.get_data()["snr"].values
-            to_remove = snrs < min_snr
-            pair_mask[to_remove, :] = False
-            pair_mask[:, to_remove] = False
-
-        # STEP : remove contaminated auto corr
-        elif step == "remove_contaminated":
-            contaminations, nb_violations = compute_refrac_period_violations(
-                sorting_analyzer, refractory_period_ms=refractory_period_ms, censored_period_ms=censored_period_ms
-            )
-            nb_violations = np.array(list(nb_violations.values()))
-            contaminations = np.array(list(contaminations.values()))
-            to_remove = contaminations > contamination_thresh
-            pair_mask[to_remove, :] = False
-            pair_mask[:, to_remove] = False
-
-        # STEP : unit positions are estimated roughly with channel
-        elif step == "unit_locations" in steps:
-            location_ext = sorting_analyzer.get_extension("unit_locations")
-            unit_locations = location_ext.get_data()[:, :2]
-
-            unit_distances = scipy.spatial.distance.cdist(unit_locations, unit_locations, metric="euclidean")
-            pair_mask = pair_mask & (unit_distances <= max_distance_um)
-            outs["unit_distances"] = unit_distances
-
-        # STEP : potential auto merge by correlogram
-        elif step == "correlogram" in steps:
-            correlograms_ext = sorting_analyzer.get_extension("correlograms")
-            correlograms, bins = correlograms_ext.get_data()
-            mask = (bins[:-1] >= -censor_correlograms_ms) & (bins[:-1] < censor_correlograms_ms)
-            correlograms[:, :, mask] = 0
-            correlograms_smoothed = smooth_correlogram(correlograms, bins, sigma_smooth_ms=sigma_smooth_ms)
-            # find correlogram window for each units
-            win_sizes = np.zeros(n, dtype=int)
-            for unit_ind in range(n):
-                auto_corr = correlograms_smoothed[unit_ind, unit_ind, :]
-                thresh = np.max(auto_corr) * adaptative_window_thresh
-                win_size = get_unit_adaptive_window(auto_corr, thresh)
-                win_sizes[unit_ind] = win_size
-            correlogram_diff = compute_correlogram_diff(
-                sorting,
-                correlograms_smoothed,
-                win_sizes,
-                pair_mask=pair_mask,
-            )
-            # print(correlogram_diff)
-            pair_mask = pair_mask & (correlogram_diff < corr_diff_thresh)
-            outs["correlograms"] = correlograms
-            outs["bins"] = bins
-            outs["correlograms_smoothed"] = correlograms_smoothed
-            outs["correlogram_diff"] = correlogram_diff
-            outs["win_sizes"] = win_sizes
-
-        # STEP : check if potential merge with CC also have template similarity
-        elif step == "template_similarity" in steps:
-            template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
-            templates_similarity = template_similarity_ext.get_data()
-            templates_diff = 1 - templates_similarity
-            pair_mask = pair_mask & (templates_diff < template_diff_thresh)
-            outs["templates_diff"] = templates_diff
-
-        # STEP : check the vicinity of the spikes
-        elif step == "knn" in steps:
-            if knn_kwargs is None:
-                knn_kwargs = dict()
-            pair_mask = get_pairs_via_nntree(sorting_analyzer, k_nn, pair_mask, **knn_kwargs)
-
-        # STEP : check how the rates overlap in times
-        elif step == "presence_distance" in steps:
-            presence_distance_kwargs = presence_distance_kwargs or dict()
-            num_samples = [
-                sorting_analyzer.get_num_samples(segment_index) for segment_index in range(sorting.get_num_segments())
-            ]
-            presence_distances = compute_presence_distance(
-                sorting, pair_mask, num_samples=num_samples, **presence_distance_kwargs
-            )
-            pair_mask = pair_mask & (presence_distances > presence_distance_thresh)
-            outs["presence_distances"] = presence_distances
-
-        # STEP : check if the cross contamination is significant
-        elif step == "cross_contamination" in steps:
-            refractory = (censored_period_ms, refractory_period_ms)
-            CC, p_values = compute_cross_contaminations(
-                sorting_analyzer, pair_mask, cc_thresh, refractory, contaminations
-            )
-            pair_mask = pair_mask & (p_values > p_value)
-            outs["cross_contaminations"] = CC, p_values
-
-        # STEP : validate the potential merges with CC increase the contamination quality metrics
-        elif step == "quality_score" in steps:
-            pair_mask, pairs_decreased_score = check_improve_contaminations_score(
-                sorting_analyzer,
-                pair_mask,
-                contaminations,
-                firing_contamination_balance,
-                refractory_period_ms,
-                censored_period_ms,
-            )
-            outs["pairs_decreased_score"] = pairs_decreased_score
-
-    # FINAL STEP : create the final list from pair_mask boolean matrix
-    ind1, ind2 = np.nonzero(pair_mask)
-    potential_merges = list(zip(unit_ids[ind1], unit_ids[ind2]))
-
-    if resolve_graph:
-        potential_merges = resolve_merging_graph(sorting, potential_merges)
-
-    if extra_outputs:
-        return potential_merges, outs
-    else:
-        return potential_merges
-
-
-def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
+    presence_distance_kwargs = presence_distance_kwargs or dict()
+    knn_kwargs = knn_kwargs or dict()
+    return auto_merges(
+        sorting_analyzer,
+        preset,
+        resolve_graph,
+        num_spikes_kwargs={"min_spikes" : min_spikes},
+        snr_kwargs={"min_snr" : min_snr},
+        remove_contaminated_kwargs={"contamination_thresh" : contamination_thresh,
+                                    "refractory_period_ms" : refractory_period_ms,
+                                    "censored_period_ms" : censored_period_ms},
+        unit_locations_kwargs={"max_distance_um" : max_distance_um},
+        correlogram_kwargs={"corr_diff_thresh" : corr_diff_thresh, 
+                            "censor_correlograms_ms" : censor_correlograms_ms, 
+                            "sigma_smooth_ms" : sigma_smooth_ms,
+                            "adaptative_window_thresh" : adaptative_window_thresh},
+        template_similarity_kwargs={"template_diff_thresh" : template_diff_thresh},
+        presence_distance_kwargs={"presence_distance_thresh" : presence_distance_thresh, **presence_distance_kwargs},
+        knn_kwargs={"k_nn" : k_nn, **knn_kwargs},
+        cross_contamination_kwargs={"cc_thresh" : cc_thresh,
+                                    "p_value" : p_value,
+                                    "refractory_period_ms" : refractory_period_ms,
+                                    "censored_period_ms" : censored_period_ms},
+        quality_score_kwargs={"firing_contamination_balance" : firing_contamination_balance,
+                            "refractory_period_ms" : refractory_period_ms,
+                            "censored_period_ms" : censored_period_ms},
+        compute_needed_extensions=False,
+        extra_outputs=extra_outputs,
+        steps=steps)
+
+
+def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, job_kwargs=None, **knn_kwargs):
 
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids

From 87158b524404ab75b5ecd3354a10743827fb2246 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 08:30:02 +0000
Subject: [PATCH 136/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 111 ++++++++++++----------
 1 file changed, 59 insertions(+), 52 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 0fcaa4c3f6..7aad846e7a 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -25,7 +25,7 @@
 _required_extensions = {
     "unit_locations": ["unit_locations"],
     "correlogram": ["correlograms"],
-    "min_snr" : ["noise_levels", "templates"],
+    "min_snr": ["noise_levels", "templates"],
     "template_similarity": ["template_similarity"],
     "knn": ["spike_locations", "spike_amplitudes"],
 }
@@ -35,32 +35,31 @@ def auto_merges(
     sorting_analyzer: SortingAnalyzer,
     preset: str | None = "similarity_correlograms",
     resolve_graph: bool = False,
-    num_spikes_kwargs={"min_spikes" : 100},
-    snr_kwargs={"min_snr" : 2},
-    remove_contaminated_kwargs={"contamination_thresh" : 0.2,
-                                "refractory_period_ms" : 1.0,
-                                "censored_period_ms" : 0.3},
-    unit_locations_kwargs={"max_distance_um" : 150},
-    correlogram_kwargs={"corr_diff_thresh" : 0.16, 
-                        "censor_correlograms_ms" : 0.15, 
-                        "sigma_smooth_ms" : 0.6,
-                        "adaptative_window_thresh" : 0.5},
-    template_similarity_kwargs={"template_diff_thresh" : 0.25},
-    presence_distance_kwargs={"presence_distance_thresh" : 100},
-    knn_kwargs={"k_nn" : 10},
-    cross_contamination_kwargs={"cc_thresh" : 0.1,
-                                "p_value" : 0.2,
-                                "refractory_period_ms" : 1.0,
-                                "censored_period_ms" : 0.3},
-    quality_score_kwargs={"firing_contamination_balance" : 2.5,
-                          "refractory_period_ms" : 1.0,
-                          "censored_period_ms" : 0.3},
+    num_spikes_kwargs={"min_spikes": 100},
+    snr_kwargs={"min_snr": 2},
+    remove_contaminated_kwargs={"contamination_thresh": 0.2, "refractory_period_ms": 1.0, "censored_period_ms": 0.3},
+    unit_locations_kwargs={"max_distance_um": 150},
+    correlogram_kwargs={
+        "corr_diff_thresh": 0.16,
+        "censor_correlograms_ms": 0.15,
+        "sigma_smooth_ms": 0.6,
+        "adaptative_window_thresh": 0.5,
+    },
+    template_similarity_kwargs={"template_diff_thresh": 0.25},
+    presence_distance_kwargs={"presence_distance_thresh": 100},
+    knn_kwargs={"k_nn": 10},
+    cross_contamination_kwargs={
+        "cc_thresh": 0.1,
+        "p_value": 0.2,
+        "refractory_period_ms": 1.0,
+        "censored_period_ms": 0.3,
+    },
+    quality_score_kwargs={"firing_contamination_balance": 2.5, "refractory_period_ms": 1.0, "censored_period_ms": 0.3},
     compute_needed_extensions: bool = True,
     extra_outputs: bool = False,
     steps: list[str] | None = None,
-    **job_kwargs
+    **job_kwargs,
 ) -> list[tuple[int | str, int | str]] | Tuple[tuple[int | str, int | str], dict]:
-    
     """
     Algorithm to find and check potential merges between units.
 
@@ -242,9 +241,9 @@ def auto_merges(
         # STEP : remove contaminated auto corr
         elif step == "remove_contaminated":
             contaminations, nb_violations = compute_refrac_period_violations(
-                sorting_analyzer, 
-                refractory_period_ms=remove_contaminated_kwargs["refractory_period_ms"], 
-                censored_period_ms=remove_contaminated_kwargs["censored_period_ms"]
+                sorting_analyzer,
+                refractory_period_ms=remove_contaminated_kwargs["refractory_period_ms"],
+                censored_period_ms=remove_contaminated_kwargs["censored_period_ms"],
             )
             nb_violations = np.array(list(nb_violations.values()))
             contaminations = np.array(list(contaminations.values()))
@@ -319,8 +318,10 @@ def auto_merges(
 
         # STEP : check if the cross contamination is significant
         elif step == "cross_contamination" in steps:
-            refractory = (cross_contamination_kwargs["censored_period_ms"], 
-                          cross_contamination_kwargs["refractory_period_ms"])
+            refractory = (
+                cross_contamination_kwargs["censored_period_ms"],
+                cross_contamination_kwargs["refractory_period_ms"],
+            )
             CC, p_values = compute_cross_contaminations(
                 sorting_analyzer, pair_mask, cross_contamination_kwargs["cc_thresh"], refractory, contaminations
             )
@@ -351,9 +352,6 @@ def auto_merges(
     else:
         return potential_merges
 
-        
-
-
 
 def get_potential_auto_merge(
     sorting_analyzer: SortingAnalyzer,
@@ -492,29 +490,38 @@ def get_potential_auto_merge(
         sorting_analyzer,
         preset,
         resolve_graph,
-        num_spikes_kwargs={"min_spikes" : min_spikes},
-        snr_kwargs={"min_snr" : min_snr},
-        remove_contaminated_kwargs={"contamination_thresh" : contamination_thresh,
-                                    "refractory_period_ms" : refractory_period_ms,
-                                    "censored_period_ms" : censored_period_ms},
-        unit_locations_kwargs={"max_distance_um" : max_distance_um},
-        correlogram_kwargs={"corr_diff_thresh" : corr_diff_thresh, 
-                            "censor_correlograms_ms" : censor_correlograms_ms, 
-                            "sigma_smooth_ms" : sigma_smooth_ms,
-                            "adaptative_window_thresh" : adaptative_window_thresh},
-        template_similarity_kwargs={"template_diff_thresh" : template_diff_thresh},
-        presence_distance_kwargs={"presence_distance_thresh" : presence_distance_thresh, **presence_distance_kwargs},
-        knn_kwargs={"k_nn" : k_nn, **knn_kwargs},
-        cross_contamination_kwargs={"cc_thresh" : cc_thresh,
-                                    "p_value" : p_value,
-                                    "refractory_period_ms" : refractory_period_ms,
-                                    "censored_period_ms" : censored_period_ms},
-        quality_score_kwargs={"firing_contamination_balance" : firing_contamination_balance,
-                            "refractory_period_ms" : refractory_period_ms,
-                            "censored_period_ms" : censored_period_ms},
+        num_spikes_kwargs={"min_spikes": min_spikes},
+        snr_kwargs={"min_snr": min_snr},
+        remove_contaminated_kwargs={
+            "contamination_thresh": contamination_thresh,
+            "refractory_period_ms": refractory_period_ms,
+            "censored_period_ms": censored_period_ms,
+        },
+        unit_locations_kwargs={"max_distance_um": max_distance_um},
+        correlogram_kwargs={
+            "corr_diff_thresh": corr_diff_thresh,
+            "censor_correlograms_ms": censor_correlograms_ms,
+            "sigma_smooth_ms": sigma_smooth_ms,
+            "adaptative_window_thresh": adaptative_window_thresh,
+        },
+        template_similarity_kwargs={"template_diff_thresh": template_diff_thresh},
+        presence_distance_kwargs={"presence_distance_thresh": presence_distance_thresh, **presence_distance_kwargs},
+        knn_kwargs={"k_nn": k_nn, **knn_kwargs},
+        cross_contamination_kwargs={
+            "cc_thresh": cc_thresh,
+            "p_value": p_value,
+            "refractory_period_ms": refractory_period_ms,
+            "censored_period_ms": censored_period_ms,
+        },
+        quality_score_kwargs={
+            "firing_contamination_balance": firing_contamination_balance,
+            "refractory_period_ms": refractory_period_ms,
+            "censored_period_ms": censored_period_ms,
+        },
         compute_needed_extensions=False,
         extra_outputs=extra_outputs,
-        steps=steps)
+        steps=steps,
+    )
 
 
 def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, job_kwargs=None, **knn_kwargs):

From 98edbdb7cfb63e931959e9191241625e1908a94a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 12:25:44 +0200
Subject: [PATCH 137/164] Fixing tests

---
 src/spikeinterface/curation/auto_merge.py           | 13 +++++++++----
 .../curation/tests/test_auto_merge.py               |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 7aad846e7a..ac77cba951 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -30,6 +30,7 @@
     "knn": ["spike_locations", "spike_amplitudes"],
 }
 
+_templates_needed = ['unit_locations', 'min_snr', 'template_similarity', 'spike_locations', 'spike_amplitudes']
 
 def auto_merges(
     sorting_analyzer: SortingAnalyzer,
@@ -201,13 +202,17 @@ def auto_merges(
         if step in _required_extensions:
             for ext in _required_extensions[step]:
                 if compute_needed_extensions:
+                    if step in _templates_needed:
+                        template_ext = sorting_analyzer.get_extension("templates")
+                        if template_ext is None:
+                            sorting_analyzer.compute(["random_spikes", "templates"])
                     params = eval(f"{step}_kwargs")
                     params = params.get(ext, dict())
                     sorting_analyzer.compute(ext, **params, **job_kwargs)
                 else:
                     if not sorting_analyzer.has_extension(ext):
                         raise ValueError(f"{step} requires {ext} extension")
-
+    
     n = unit_ids.size
     pair_mask = np.triu(np.arange(n)) > 0
     outs = dict()
@@ -228,7 +233,7 @@ def auto_merges(
         elif step == "snr":
             qm_ext = sorting_analyzer.get_extension("quality_metrics")
             if qm_ext is None:
-                sorting_analyzer.compute(["noise_levels", "random_spikes", "templates"], **job_kwargs)
+                sorting_analyzer.compute(["noise_levels"], **job_kwargs)
                 sorting_analyzer.compute("quality_metrics", metric_names=["snr"], **job_kwargs)
                 qm_ext = sorting_analyzer.get_extension("quality_metrics")
 
@@ -301,7 +306,7 @@ def auto_merges(
 
         # STEP : check the vicinity of the spikes
         elif step == "knn" in steps:
-            pair_mask = get_pairs_via_nntree(sorting_analyzer, **knn_kwargs, pair_mask=pair_mask, job_kwargs=job_kwargs)
+            pair_mask = get_pairs_via_nntree(sorting_analyzer, **knn_kwargs, pair_mask=pair_mask)
 
         # STEP : check how the rates overlap in times
         elif step == "presence_distance" in steps:
@@ -524,7 +529,7 @@ def get_potential_auto_merge(
     )
 
 
-def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, job_kwargs=None, **knn_kwargs):
+def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
 
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids
diff --git a/src/spikeinterface/curation/tests/test_auto_merge.py b/src/spikeinterface/curation/tests/test_auto_merge.py
index ca8324e106..2dffd685a5 100644
--- a/src/spikeinterface/curation/tests/test_auto_merge.py
+++ b/src/spikeinterface/curation/tests/test_auto_merge.py
@@ -71,7 +71,7 @@ def test_get_auto_merge_list(sorting_analyzer_for_curation, preset):
         with pytest.raises(ValueError):
             potential_merges = get_potential_auto_merge(sorting_analyzer, preset=preset)
         potential_merges = get_potential_auto_merge(
-            sorting_analyzer, preset=preset, steps=["min_spikes", "min_snr", "remove_contaminated", "unit_locations"]
+            sorting_analyzer, preset=preset, steps=["num_spikes", "snr", "remove_contaminated", "unit_locations"]
         )
 
     # DEBUG

From 85623ceea0d35dbac715719c8214be6f858cd6d8 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 10:26:09 +0000
Subject: [PATCH 138/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index ac77cba951..09feb371d6 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -30,7 +30,8 @@
     "knn": ["spike_locations", "spike_amplitudes"],
 }
 
-_templates_needed = ['unit_locations', 'min_snr', 'template_similarity', 'spike_locations', 'spike_amplitudes']
+_templates_needed = ["unit_locations", "min_snr", "template_similarity", "spike_locations", "spike_amplitudes"]
+
 
 def auto_merges(
     sorting_analyzer: SortingAnalyzer,
@@ -212,7 +213,7 @@ def auto_merges(
                 else:
                     if not sorting_analyzer.has_extension(ext):
                         raise ValueError(f"{step} requires {ext} extension")
-    
+
     n = unit_ids.size
     pair_mask = np.triu(np.arange(n)) > 0
     outs = dict()

From 164fa5802228bfa3852310941ea87374fd2a9b42 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 13:01:16 +0200
Subject: [PATCH 139/164] Adding iterative merges

---
 src/spikeinterface/curation/auto_merge.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index ac77cba951..ec10c0b468 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -32,6 +32,7 @@
 
 _templates_needed = ['unit_locations', 'min_snr', 'template_similarity', 'spike_locations', 'spike_amplitudes']
 
+
 def auto_merges(
     sorting_analyzer: SortingAnalyzer,
     preset: str | None = "similarity_correlograms",
@@ -529,6 +530,26 @@ def get_potential_auto_merge(
     )
 
 
+def iterative_merges(sorting_analyzer, 
+                         presets, 
+                         params=None, 
+                         merging_params={'merging_mode' : 'soft', "censor_ms" : 3},
+                         compute_needed_extensions=True,
+                         verbose=False,
+                         **job_kwargs):
+    if params is None:
+        params = [{}]*len(presets)
+
+    assert len(presets) == len(params)
+
+    for i in range(len(presets)):
+        merges = auto_merges(sorting_analyzer, resolve_graph=True, compute_needed_extensions=compute_needed_extensions, **params[i], **job_kwargs)
+        if verbose:
+            n_merges = len(merges)
+            print(f"{n_merges} have been made during pass", presets[i])
+        sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_params, **job_kwargs)
+    return sorting_analyzer
+
 def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
 
     sorting = sorting_analyzer.sorting

From c6e1e00ab213d2ad606fa6f8cc4dac2f6f2771a5 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 11:01:48 +0000
Subject: [PATCH 140/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 28 +++++++++++++++--------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 888bd25ecc..ac85cb8e12 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -33,7 +33,6 @@
 _templates_needed = ["unit_locations", "min_snr", "template_similarity", "spike_locations", "spike_amplitudes"]
 
 
-
 def auto_merges(
     sorting_analyzer: SortingAnalyzer,
     preset: str | None = "similarity_correlograms",
@@ -531,26 +530,35 @@ def get_potential_auto_merge(
     )
 
 
-def iterative_merges(sorting_analyzer, 
-                         presets, 
-                         params=None, 
-                         merging_params={'merging_mode' : 'soft', "censor_ms" : 3},
-                         compute_needed_extensions=True,
-                         verbose=False,
-                         **job_kwargs):
+def iterative_merges(
+    sorting_analyzer,
+    presets,
+    params=None,
+    merging_params={"merging_mode": "soft", "censor_ms": 3},
+    compute_needed_extensions=True,
+    verbose=False,
+    **job_kwargs,
+):
     if params is None:
-        params = [{}]*len(presets)
+        params = [{}] * len(presets)
 
     assert len(presets) == len(params)
 
     for i in range(len(presets)):
-        merges = auto_merges(sorting_analyzer, resolve_graph=True, compute_needed_extensions=compute_needed_extensions, **params[i], **job_kwargs)
+        merges = auto_merges(
+            sorting_analyzer,
+            resolve_graph=True,
+            compute_needed_extensions=compute_needed_extensions,
+            **params[i],
+            **job_kwargs,
+        )
         if verbose:
             n_merges = len(merges)
             print(f"{n_merges} have been made during pass", presets[i])
         sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_params, **job_kwargs)
     return sorting_analyzer
 
+
 def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
 
     sorting = sorting_analyzer.sorting

From d3bb0a20ae0265f35051fb2212d9868532eba319 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 14:39:08 +0200
Subject: [PATCH 141/164] Refactoring

---
 src/spikeinterface/curation/auto_merge.py     |  13 ++-
 .../benchmark/benchmark_merging.py            |   3 +-
 .../sortingcomponents/merging/circus.py       | 107 ++++--------------
 .../sortingcomponents/merging/knn.py          |  99 ----------------
 .../sortingcomponents/merging/lussac.py       |  95 ++++------------
 .../sortingcomponents/merging/main.py         |  42 ++++++-
 .../sortingcomponents/merging/method_list.py  |   3 +-
 7 files changed, 90 insertions(+), 272 deletions(-)
 delete mode 100644 src/spikeinterface/sortingcomponents/merging/knn.py

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 888bd25ecc..100cf18b3b 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -534,7 +534,7 @@ def get_potential_auto_merge(
 def iterative_merges(sorting_analyzer, 
                          presets, 
                          params=None, 
-                         merging_params={'merging_mode' : 'soft', "censor_ms" : 3},
+                         merging_kwargs={'merging_mode' : 'soft', "sparsity_overlap" : 0.5, "censor_ms" : 3},
                          compute_needed_extensions=True,
                          verbose=False,
                          **job_kwargs):
@@ -544,11 +544,16 @@ def iterative_merges(sorting_analyzer,
     assert len(presets) == len(params)
 
     for i in range(len(presets)):
-        merges = auto_merges(sorting_analyzer, resolve_graph=True, compute_needed_extensions=compute_needed_extensions, **params[i], **job_kwargs)
+        merges = auto_merges(sorting_analyzer, 
+                             resolve_graph=True, 
+                             compute_needed_extensions=compute_needed_extensions * (i==0), 
+                             extra_outputs=False,
+                             **params[i], **job_kwargs)
         if verbose:
             n_merges = len(merges)
-            print(f"{n_merges} have been made during pass", presets[i])
-        sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_params, **job_kwargs)
+            print(f"{n_merges} merges have been made during pass", presets[i])
+
+        sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_kwargs, **job_kwargs)
     return sorting_analyzer
 
 def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index e6a5daee1b..27d7db3e70 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -25,12 +25,11 @@ def __init__(self, recording, splitted_sorting, params, gt_sorting, splitted_cel
         self.result = {}
 
     def run(self, **job_kwargs):
-        self.result["sorting"], self.result["merges"] = merge_spikes(
+        self.result["sorting"] = merge_spikes(
             self.recording,
             self.splitted_sorting,
             method=self.method,
             method_kwargs=self.method_kwargs,
-            extra_outputs=True,
         )
 
     def compute_result(self, **result_params):
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 28d702b484..f616ede8da 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -2,11 +2,7 @@
 import numpy as np
 
 from .main import BaseMergingEngine
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.curation.curation_tools import resolve_merging_graph
-from spikeinterface.core.sorting_tools import apply_merges_to_sorting
+from spikeinterface.curation.auto_merge import iterative_merges
 
 
 class CircusMerging(BaseMergingEngine):
@@ -15,88 +11,27 @@ class CircusMerging(BaseMergingEngine):
     """
 
     default_params = {
-        "templates": None,
-        "verbose": False,
-        "remove_emtpy": True,
-        "recursive": False,
-        "censor_ms": 3,
-        "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
-        "curation_kwargs": {
-            "minimum_spikes": 50,
-            "maximum_distance_um": 50,
-        },
-        "temporal_splits_kwargs": {
-            "minimum_spikes": 50,
-            "maximum_distance_um": 50,
-            "presence_distance_thresh": 100,
-            "template_diff_thresh": 0.5,
-        },
+        "verbose": True,
+        "merging_kwargs": {'merging_mode' : 'soft', "sparsity_overlap" : 0.5, "censor_ms" : 3},
+        "similarity_correlograms_kwargs" : None,
+        "temporal_splits_kwargs" : None
     }
 
-    def __init__(self, recording, sorting, kwargs):
+    def __init__(self, sorting_analyzer, kwargs):
         self.params = self.default_params.copy()
         self.params.update(**kwargs)
-        self.sorting = sorting
-        self.recording = recording
-        self.remove_empty = self.params.get("remove_empty", True)
-        self.verbose = self.params.pop("verbose")
-        self.templates = self.params.pop("templates", None)
-        self.recursive = self.params.pop("recursive", True)
-
-        if self.templates is not None:
-            sparsity = self.templates.sparsity
-            templates_array = self.templates.get_dense_templates().copy()
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
-            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
-            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
-            self.analyzer.extensions["templates"].data["average"] = templates_array
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        else:
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(["random_spikes", "templates"])
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-
-        if self.remove_empty:
-            from spikeinterface.curation.curation_tools import remove_empty_units
-
-            self.analyzer = remove_empty_units(self.analyzer)
-
-        self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
-
-    def _get_new_sorting(self):
-        curation_kwargs = self.params.get("curation_kwargs", None)
-        if curation_kwargs is not None:
-            merges = get_potential_auto_merge(self.analyzer, **curation_kwargs, preset="default")
-        else:
-            merges = []
-        if self.verbose:
-            print(f"{len(merges)} merges have been detected via auto merges")
-        temporal_splits_kwargs = self.params.get("temporal_splits_kwargs", None)
-        if temporal_splits_kwargs is not None:
-            more_merges = get_potential_auto_merge(self.analyzer, **temporal_splits_kwargs, preset="temporal_splits")
-            if self.verbose:
-                print(f"{len(more_merges)} merges have been detected via additional temporal splits")
-            merges += more_merges
-        units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"])
-        return new_sorting, merges
-
-    def run(self, extra_outputs=False):
-        sorting, merges = self._get_new_sorting()
-        num_merges = len(merges)
-        all_merges = [merges]
-
-        if self.recursive:
-            while num_merges > 0:
-                self.analyzer = create_sorting_analyzer(sorting, self.recording, format="memory")
-                self.analyzer.compute(["random_spikes", "templates"])
-                self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-                self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
-                sorting, merges = self._get_new_sorting()
-                num_merges = len(merges)
-                all_merges += [merges]
-
-        if extra_outputs:
-            return sorting, all_merges
-        else:
-            return sorting
+        self.analyzer = sorting_analyzer
+        self.verbose = self.params["verbose"]
+
+    def run(self, **job_kwargs):
+        presets=['similarity_correlograms', 'temporal_splits']
+        similarity_kwargs = self.params["similarity_correlograms_kwargs"] or dict()
+        temporal_kwargs = self.params["temporal_splits_kwargs"] or dict()
+        params = [similarity_kwargs, temporal_kwargs]
+        analyzer = iterative_merges(self.analyzer, 
+                                    presets=presets, 
+                                    params=params, 
+                                    verbose=self.verbose, 
+                                    merging_kwargs=self.params["merging_kwargs"],
+                                    **job_kwargs)
+        return analyzer.sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/knn.py b/src/spikeinterface/sortingcomponents/merging/knn.py
deleted file mode 100644
index 14288fd1ab..0000000000
--- a/src/spikeinterface/sortingcomponents/merging/knn.py
+++ /dev/null
@@ -1,99 +0,0 @@
-from __future__ import annotations
-import numpy as np
-import math
-
-try:
-    import numba
-
-    HAVE_NUMBA = True
-except ImportError:
-    HAVE_NUMBA = False
-
-from .main import BaseMergingEngine
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.curation.curation_tools import resolve_merging_graph
-from spikeinterface.core.sorting_tools import apply_merges_to_sorting
-
-
-class KNNMerging(BaseMergingEngine):
-    """
-    Meta merging inspired from the Lussac metric
-    """
-
-    default_params = {
-        "templates": None,
-        "verbose": False,
-        "censor_ms": 3,
-        "remove_emtpy": True,
-        "recursive": True,
-        "knn_kwargs": {
-            "minimum_spikes": 50,
-            "maximum_distance_um": 50,
-            "k_nn": 5,
-        },
-    }
-
-    def __init__(self, recording, sorting, kwargs):
-        self.params = self.default_params.copy()
-        self.params.update(**kwargs)
-        self.sorting = sorting
-        self.verbose = self.params.pop("verbose")
-        self.remove_empty = self.params.get("remove_empty", True)
-        self.recording = recording
-        self.templates = self.params.pop("templates", None)
-        self.recursive = self.params.pop("recursive", True)
-
-        if self.templates is not None:
-            sparsity = self.templates.sparsity
-            templates_array = self.templates.get_dense_templates().copy()
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
-            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
-            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
-            self.analyzer.extensions["templates"].data["average"] = templates_array
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-            self.analyzer.compute("spike_locations", "grid_convolution")
-            self.analyzer.compute("spike_amplitudes")
-        else:
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(["random_spikes", "templates"])
-            self.analyzer.compute("spike_locations", "grid_convolution")
-            self.analyzer.compute("spike_amplitudes")
-
-        if self.remove_empty:
-            from spikeinterface.curation.curation_tools import remove_empty_units
-
-            self.analyzer = remove_empty_units(self.analyzer)
-
-    def _get_new_sorting(self):
-        knn_kwargs = self.params.get("knn_kwargs", None)
-        merges = get_potential_auto_merge(self.analyzer, **knn_kwargs, preset="knn")
-
-        if self.verbose:
-            print(f"{len(merges)} merges have been detected")
-        units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"])
-        return new_sorting, merges
-
-    def run(self, extra_outputs=False):
-
-        sorting, merges = self._get_new_sorting()
-        num_merges = len(merges)
-        all_merges = [merges]
-
-        if self.recursive:
-            while num_merges > 0:
-                self.analyzer = create_sorting_analyzer(sorting, self.recording, format="memory")
-                self.analyzer.compute(["random_spikes", "templates"])
-                self.analyzer.compute("spike_locations", "grid_convolution")
-                self.analyzer.compute("spike_amplitudes")
-                self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-                sorting, merges = self._get_new_sorting()
-                num_merges = len(merges)
-                all_merges += [merges]
-
-        if extra_outputs:
-            return sorting, all_merges
-        else:
-            return sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index b75ac1d7a5..e82976e45a 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -1,13 +1,8 @@
 from __future__ import annotations
 import numpy as np
-import math
 
 from .main import BaseMergingEngine
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.curation.curation_tools import resolve_merging_graph
-from spikeinterface.core.sorting_tools import apply_merges_to_sorting
+from spikeinterface.curation.auto_merge import iterative_merges
 
 
 class LussacMerging(BaseMergingEngine):
@@ -16,75 +11,27 @@ class LussacMerging(BaseMergingEngine):
     """
 
     default_params = {
-        "templates": None,
-        "verbose": False,
-        "censor_ms": 3,
-        "remove_emtpy": True,
-        "recursive": False,
-        "similarity_kwargs": {"method": "l2", "support": "union", "max_lag_ms": 0.2},
-        "lussac_kwargs": {
-            "minimum_spikes": 50,
-            "maximum_distance_um": 50,
-        },
+        "verbose": True,
+        "merging_kwargs": {'merging_mode' : 'soft', "sparsity_overlap" : 0.5, "censor_ms" : 3},
+        "template_diff_thresh" : np.arange(0, 0.5, 0.05),
+        "x_contaminations_kwargs" : None
     }
 
-    def __init__(self, recording, sorting, kwargs):
+    def __init__(self, sorting_analyzer, kwargs):
         self.params = self.default_params.copy()
         self.params.update(**kwargs)
-        self.sorting = sorting
-        self.verbose = self.params.pop("verbose")
-        self.remove_empty = self.params.get("remove_empty", True)
-        self.recording = recording
-        self.templates = self.params.pop("templates", None)
-        self.recursive = self.params.pop("recursive", True)
-
-        if self.templates is not None:
-            sparsity = self.templates.sparsity
-            templates_array = self.templates.get_dense_templates().copy()
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory", sparsity=sparsity)
-            self.analyzer.extensions["templates"] = ComputeTemplates(self.analyzer)
-            self.analyzer.extensions["templates"].params = {"nbefore": self.templates.nbefore}
-            self.analyzer.extensions["templates"].data["average"] = templates_array
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-        else:
-            self.analyzer = create_sorting_analyzer(sorting, recording, format="memory")
-            self.analyzer.compute(["random_spikes", "templates"])
-            self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-
-        if self.remove_empty:
-            from spikeinterface.curation.curation_tools import remove_empty_units
-
-            self.analyzer = remove_empty_units(self.analyzer)
-
-        self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
-
-    def _get_new_sorting(self):
-        lussac_kwargs = self.params.get("lussac_kwargs", None)
-        merges = get_potential_auto_merge(self.analyzer, **lussac_kwargs, preset="lussac")
-
-        if self.verbose:
-            print(f"{len(merges)} merges have been detected")
-        units_to_merge = resolve_merging_graph(self.analyzer.sorting, merges)
-        new_sorting = apply_merges_to_sorting(self.analyzer.sorting, units_to_merge, censor_ms=self.params["censor_ms"])
-        return new_sorting, merges
-
-    def run(self, extra_outputs=False):
-
-        sorting, merges = self._get_new_sorting()
-        num_merges = len(merges)
-        all_merges = [merges]
-
-        if self.recursive:
-            while num_merges > 0:
-                self.analyzer = create_sorting_analyzer(sorting, self.recording, format="memory")
-                self.analyzer.compute(["random_spikes", "templates"])
-                self.analyzer.compute("unit_locations", method="monopolar_triangulation")
-                self.analyzer.compute("template_similarity", **self.params["similarity_kwargs"])
-                sorting, merges = self._get_new_sorting()
-                num_merges = len(merges)
-                all_merges += [merges]
-
-        if extra_outputs:
-            return sorting, all_merges
-        else:
-            return sorting
+        self.analyzer = sorting_analyzer
+        self.verbose = self.params["verbose"]
+        self.iterations = self.params["template_diff_thresh"]
+
+    def run(self, **job_kwargs):
+        presets=['x_contaminations']*len(self.iterations)
+        params = [{"template_similarity_kwargs" : {"template_diff_thresh" : i}} for i in self.iterations]
+        merging_kwargs = self.params["merging_kwargs"] or dict()
+        analyzer = iterative_merges(self.analyzer, 
+                                    presets=presets, 
+                                    params=params, 
+                                    verbose=self.verbose, 
+                                    merging_kwargs=merging_kwargs,
+                                    **job_kwargs)
+        return analyzer.sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index c34a72a45b..d4bbcc87b7 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -2,10 +2,33 @@
 
 from threadpoolctl import threadpool_limits
 import numpy as np
+from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
+from spikeinterface.core.sparsity import ChannelSparsity
+from spikeinterface.core.analyzer_extension_core import ComputeTemplates
 
 
+def create_sorting_analyzer_with_templates(sorting, recording, templates, remove_empty=True):
+    sparsity = templates.sparsity
+    templates_array = templates.get_dense_templates().copy()
+
+    if remove_empty:
+        non_empty_unit_ids = sorting.get_non_empty_unit_ids()
+        non_empty_sorting = sorting.remove_empty_units()
+        non_empty_unit_indices = sorting.ids_to_indices(non_empty_unit_ids)
+        templates_array = templates_array[non_empty_unit_indices]
+        sparsity_mask = sparsity.mask[non_empty_unit_indices, :]
+        sparsity = ChannelSparsity(sparsity_mask, non_empty_unit_ids, sparsity.channel_ids)
+    else:
+        non_empty_sorting = sorting
+
+    sa = create_sorting_analyzer(non_empty_sorting, recording, format="memory", sparsity=sparsity)
+    sa.extensions["templates"] = ComputeTemplates(sa)
+    sa.extensions["templates"].params = {"ms_before": templates.ms_before, "ms_after": templates.ms_after}
+    sa.extensions["templates"].data["average"] = templates_array
+    return sa
+
 def merge_spikes(
-    recording, sorting, method="circus", method_kwargs={}, extra_outputs=False, verbose=False, **job_kwargs
+    recording, sorting, method="circus", templates=None, remove_empty=True, method_kwargs={}, verbose=False, **job_kwargs
 ):
     """Find spike from a recording from given templates.
 
@@ -35,19 +58,28 @@ def merge_spikes(
     assert method in merging_methods, f"The 'method' {method} is not valid. Use a method from {merging_methods}"
 
     method_class = merging_methods[method]
-    method_instance = method_class(recording, sorting, method_kwargs)
-    return method_instance.run(extra_outputs=extra_outputs)
+
+    if templates is None:
+        if remove_empty:
+            non_empty_sorting = sorting.remove_empty_units()
+            sorting_analyzer = create_sorting_analyzer(non_empty_sorting, recording)
+    else:
+        sorting_analyzer = create_sorting_analyzer_with_templates(sorting, recording, templates, remove_empty)
+
+    method_instance = method_class(sorting_analyzer, method_kwargs)
+
+    return method_instance.run(**job_kwargs)
 
 
 # generic class for template engine
 class BaseMergingEngine:
     default_params = {}
 
-    def __init__(self, recording, sorting, kwargs):
+    def __init__(self, sorting_analyzer, kwargs):
         """This function runs before loops"""
         # need to be implemented in subclass
         raise NotImplementedError
 
-    def run(self):
+    def run(self, **job_kwargs):
         # need to be implemented in subclass
         raise NotImplementedError
diff --git a/src/spikeinterface/sortingcomponents/merging/method_list.py b/src/spikeinterface/sortingcomponents/merging/method_list.py
index fb348f9faa..db1bb116e3 100644
--- a/src/spikeinterface/sortingcomponents/merging/method_list.py
+++ b/src/spikeinterface/sortingcomponents/merging/method_list.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 from .circus import CircusMerging
 from .lussac import LussacMerging
-from .knn import KNNMerging
 
-merging_methods = {"circus": CircusMerging, "lussac": LussacMerging, "knn": KNNMerging}
+merging_methods = {"circus": CircusMerging, "lussac": LussacMerging}

From c89124581d75751efb77ca65ed12d6bb9823e3e0 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 12:40:26 +0000
Subject: [PATCH 142/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py     | 29 +++++++++++--------
 .../sortingcomponents/merging/circus.py       | 22 +++++++-------
 .../sortingcomponents/merging/lussac.py       | 24 ++++++++-------
 .../sortingcomponents/merging/main.py         | 10 ++++++-
 4 files changed, 51 insertions(+), 34 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index e81e25172d..3f794c291b 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -530,24 +530,29 @@ def get_potential_auto_merge(
     )
 
 
-def iterative_merges(sorting_analyzer, 
-                         presets, 
-                         params=None, 
-                         merging_kwargs={'merging_mode' : 'soft', "sparsity_overlap" : 0.5, "censor_ms" : 3},
-                         compute_needed_extensions=True,
-                         verbose=False,
-                         **job_kwargs):
+def iterative_merges(
+    sorting_analyzer,
+    presets,
+    params=None,
+    merging_kwargs={"merging_mode": "soft", "sparsity_overlap": 0.5, "censor_ms": 3},
+    compute_needed_extensions=True,
+    verbose=False,
+    **job_kwargs,
+):
     if params is None:
         params = [{}] * len(presets)
 
     assert len(presets) == len(params)
 
     for i in range(len(presets)):
-        merges = auto_merges(sorting_analyzer, 
-                             resolve_graph=True, 
-                             compute_needed_extensions=compute_needed_extensions * (i==0), 
-                             extra_outputs=False,
-                             **params[i], **job_kwargs)
+        merges = auto_merges(
+            sorting_analyzer,
+            resolve_graph=True,
+            compute_needed_extensions=compute_needed_extensions * (i == 0),
+            extra_outputs=False,
+            **params[i],
+            **job_kwargs,
+        )
         if verbose:
             n_merges = len(merges)
             print(f"{n_merges} merges have been made during pass", presets[i])
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index f616ede8da..96c2e93248 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -12,9 +12,9 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "merging_kwargs": {'merging_mode' : 'soft', "sparsity_overlap" : 0.5, "censor_ms" : 3},
-        "similarity_correlograms_kwargs" : None,
-        "temporal_splits_kwargs" : None
+        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.5, "censor_ms": 3},
+        "similarity_correlograms_kwargs": None,
+        "temporal_splits_kwargs": None,
     }
 
     def __init__(self, sorting_analyzer, kwargs):
@@ -24,14 +24,16 @@ def __init__(self, sorting_analyzer, kwargs):
         self.verbose = self.params["verbose"]
 
     def run(self, **job_kwargs):
-        presets=['similarity_correlograms', 'temporal_splits']
+        presets = ["similarity_correlograms", "temporal_splits"]
         similarity_kwargs = self.params["similarity_correlograms_kwargs"] or dict()
         temporal_kwargs = self.params["temporal_splits_kwargs"] or dict()
         params = [similarity_kwargs, temporal_kwargs]
-        analyzer = iterative_merges(self.analyzer, 
-                                    presets=presets, 
-                                    params=params, 
-                                    verbose=self.verbose, 
-                                    merging_kwargs=self.params["merging_kwargs"],
-                                    **job_kwargs)
+        analyzer = iterative_merges(
+            self.analyzer,
+            presets=presets,
+            params=params,
+            verbose=self.verbose,
+            merging_kwargs=self.params["merging_kwargs"],
+            **job_kwargs,
+        )
         return analyzer.sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index e82976e45a..57a8aa37c1 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,9 +12,9 @@ class LussacMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "merging_kwargs": {'merging_mode' : 'soft', "sparsity_overlap" : 0.5, "censor_ms" : 3},
-        "template_diff_thresh" : np.arange(0, 0.5, 0.05),
-        "x_contaminations_kwargs" : None
+        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.5, "censor_ms": 3},
+        "template_diff_thresh": np.arange(0, 0.5, 0.05),
+        "x_contaminations_kwargs": None,
     }
 
     def __init__(self, sorting_analyzer, kwargs):
@@ -25,13 +25,15 @@ def __init__(self, sorting_analyzer, kwargs):
         self.iterations = self.params["template_diff_thresh"]
 
     def run(self, **job_kwargs):
-        presets=['x_contaminations']*len(self.iterations)
-        params = [{"template_similarity_kwargs" : {"template_diff_thresh" : i}} for i in self.iterations]
+        presets = ["x_contaminations"] * len(self.iterations)
+        params = [{"template_similarity_kwargs": {"template_diff_thresh": i}} for i in self.iterations]
         merging_kwargs = self.params["merging_kwargs"] or dict()
-        analyzer = iterative_merges(self.analyzer, 
-                                    presets=presets, 
-                                    params=params, 
-                                    verbose=self.verbose, 
-                                    merging_kwargs=merging_kwargs,
-                                    **job_kwargs)
+        analyzer = iterative_merges(
+            self.analyzer,
+            presets=presets,
+            params=params,
+            verbose=self.verbose,
+            merging_kwargs=merging_kwargs,
+            **job_kwargs,
+        )
         return analyzer.sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index d4bbcc87b7..ec70f2418e 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -27,8 +27,16 @@ def create_sorting_analyzer_with_templates(sorting, recording, templates, remove
     sa.extensions["templates"].data["average"] = templates_array
     return sa
 
+
 def merge_spikes(
-    recording, sorting, method="circus", templates=None, remove_empty=True, method_kwargs={}, verbose=False, **job_kwargs
+    recording,
+    sorting,
+    method="circus",
+    templates=None,
+    remove_empty=True,
+    method_kwargs={},
+    verbose=False,
+    **job_kwargs,
 ):
     """Find spike from a recording from given templates.
 

From 64d2780f184f194ee157dd89a52adcf9c252ead9 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 15:05:00 +0200
Subject: [PATCH 143/164] WIP

---
 src/spikeinterface/curation/auto_merge.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 3f794c291b..cbbc712b39 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -40,7 +40,7 @@ def auto_merges(
     num_spikes_kwargs={"min_spikes": 100},
     snr_kwargs={"min_snr": 2},
     remove_contaminated_kwargs={"contamination_thresh": 0.2, "refractory_period_ms": 1.0, "censored_period_ms": 0.3},
-    unit_locations_kwargs={"max_distance_um": 150},
+    unit_locations_kwargs={"max_distance_um": 50},
     correlogram_kwargs={
         "corr_diff_thresh": 0.16,
         "censor_correlograms_ms": 0.15,
@@ -554,7 +554,7 @@ def iterative_merges(
             **job_kwargs,
         )
         if verbose:
-            n_merges = len(merges)
+            n_merges = np.sum([len(i) for i in merges])
             print(f"{n_merges} merges have been made during pass", presets[i])
 
         sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_kwargs, **job_kwargs)

From 878fe99fb9daa2672f65fa972222970376fc868f Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 16:46:44 +0200
Subject: [PATCH 144/164] Bringing back the components

---
 src/spikeinterface/curation/auto_merge.py     |  2 +-
 .../sorters/internal/spyking_circus2.py       | 57 +------------------
 .../sortingcomponents/merging/circus.py       |  2 +-
 .../sortingcomponents/merging/lussac.py       |  2 +-
 4 files changed, 6 insertions(+), 57 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index cbbc712b39..2ca2e32751 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -554,7 +554,7 @@ def iterative_merges(
             **job_kwargs,
         )
         if verbose:
-            n_merges = np.sum([len(i) for i in merges])
+            n_merges = int(np.sum([len(i) for i in merges]))
             print(f"{n_merges} merges have been made during pass", presets[i])
 
         sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_kwargs, **job_kwargs)
diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 40beb6f50a..e39f352faf 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -14,10 +14,6 @@
 from spikeinterface.sortingcomponents.tools import cache_preprocessing
 from spikeinterface.core.basesorting import minimum_spike_dtype
 from spikeinterface.core.sparsity import compute_sparsity
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.curation.auto_merge import get_potential_auto_merge
-from spikeinterface.core.analyzer_extension_core import ComputeTemplates
-from spikeinterface.core.sparsity import ChannelSparsity
 
 
 class Spykingcircus2Sorter(ComponentsBasedSorter):
@@ -37,14 +33,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {
-            "similarity_kwargs": {"method": "cosine", "support": "union", "max_lag_ms": 0.2},
-            "correlograms_kwargs": {},
-            "auto_merge": {
-                "min_spikes": 10,
-                "corr_diff_thresh": 0.25,
-            },
-        },
+        "merging": {"method" : "lussac"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
@@ -340,8 +329,7 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
                 sorting.save(folder=curation_folder)
                 # np.save(fitting_folder / "amplitudes", guessed_amplitudes)
 
-            merging_params["method_kwargs"] = {"templates": templates}
-            sorting = merge_spikes(recording_w, sorting, **merging_params)
+            sorting = merge_spikes(recording_w, sorting, templates=templates, verbose=verbose, **merging_params)
 
             if verbose:
                 print(f"Final merging, keeping {len(sorting.unit_ids)} units")
@@ -360,43 +348,4 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         sorting = sorting.save(folder=sorting_folder)
         set_global_job_kwargs(**job_kwargs_before)
 
-        return sorting
-
-
-def create_sorting_analyzer_with_templates(sorting, recording, templates, remove_empty=True):
-    sparsity = templates.sparsity
-    templates_array = templates.get_dense_templates().copy()
-
-    if remove_empty:
-        non_empty_unit_ids = sorting.get_non_empty_unit_ids()
-        non_empty_sorting = sorting.remove_empty_units()
-        non_empty_unit_indices = sorting.ids_to_indices(non_empty_unit_ids)
-        templates_array = templates_array[non_empty_unit_indices]
-        sparsity_mask = sparsity.mask[non_empty_unit_indices, :]
-        sparsity = ChannelSparsity(sparsity_mask, non_empty_unit_ids, sparsity.channel_ids)
-    else:
-        non_empty_sorting = sorting
-
-    sa = create_sorting_analyzer(non_empty_sorting, recording, format="memory", sparsity=sparsity)
-    sa.extensions["templates"] = ComputeTemplates(sa)
-    sa.extensions["templates"].params = {"ms_before": templates.ms_before, "ms_after": templates.ms_after}
-    sa.extensions["templates"].data["average"] = templates_array
-    return sa
-
-
-def final_cleaning_circus(recording, sorting, templates, **merging_kwargs):
-
-    from spikeinterface.core.sorting_tools import apply_merges_to_sorting
-
-    sa = create_sorting_analyzer_with_templates(sorting, recording, templates)
-
-    sa.compute("unit_locations", method="monopolar_triangulation")
-    similarity_kwargs = merging_kwargs.pop("similarity_kwargs", {})
-    sa.compute("template_similarity", **similarity_kwargs)
-    correlograms_kwargs = merging_kwargs.pop("correlograms_kwargs", {})
-    sa.compute("correlograms", **correlograms_kwargs)
-    auto_merge_kwargs = merging_kwargs.pop("auto_merge", {})
-    merges = get_potential_auto_merge(sa, resolve_graph=True, **auto_merge_kwargs)
-    sorting = apply_merges_to_sorting(sa.sorting, merges)
-
-    return sorting
+        return sorting
\ No newline at end of file
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 96c2e93248..c1e713b261 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -12,7 +12,7 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.5, "censor_ms": 3},
+        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
         "similarity_correlograms_kwargs": None,
         "temporal_splits_kwargs": None,
     }
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 57a8aa37c1..6704cf496c 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,7 +12,7 @@ class LussacMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.5, "censor_ms": 3},
+        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
         "template_diff_thresh": np.arange(0, 0.5, 0.05),
         "x_contaminations_kwargs": None,
     }

From 09eeef3ca90a4cd4379f8b71f6f0cc0db9a159d6 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 14:53:11 +0000
Subject: [PATCH 145/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index e39f352faf..eb66915fbc 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -33,7 +33,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         },
         "apply_motion_correction": True,
         "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
-        "merging": {"method" : "lussac"},
+        "merging": {"method": "lussac"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},
         "apply_preprocessing": True,
@@ -348,4 +348,4 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         sorting = sorting.save(folder=sorting_folder)
         set_global_job_kwargs(**job_kwargs_before)
 
-        return sorting
\ No newline at end of file
+        return sorting

From 2b0c6bc9df4729b85b7079e9159fcf3cf611b0bb Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 21:21:01 +0200
Subject: [PATCH 146/164] WIP

---
 src/spikeinterface/curation/auto_merge.py              | 3 ++-
 src/spikeinterface/sorters/internal/spyking_circus2.py | 9 ---------
 src/spikeinterface/sortingcomponents/merging/circus.py | 5 ++++-
 src/spikeinterface/sortingcomponents/merging/lussac.py | 9 ++++++++-
 4 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 2ca2e32751..e914f60aad 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -43,7 +43,7 @@ def auto_merges(
     unit_locations_kwargs={"max_distance_um": 50},
     correlogram_kwargs={
         "corr_diff_thresh": 0.16,
-        "censor_correlograms_ms": 0.15,
+        "censor_correlograms_ms": 0.3,
         "sigma_smooth_ms": 0.6,
         "adaptative_window_thresh": 0.5,
     },
@@ -547,6 +547,7 @@ def iterative_merges(
     for i in range(len(presets)):
         merges = auto_merges(
             sorting_analyzer,
+            preset=presets[i],
             resolve_graph=True,
             compute_needed_extensions=compute_needed_extensions * (i == 0),
             extra_outputs=False,
diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index eb66915fbc..6a8cbbd5a1 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -305,15 +305,6 @@ def _run_from_folder(cls, sorter_output_folder, params, verbose):
         merging_method = merging_params.get("method", None)
 
         if merging_method is not None:
-            if params["motion_correction"] and motion_folder is not None:
-                from spikeinterface.preprocessing.motion import load_motion_info
-
-                motion_info = load_motion_info(motion_folder)
-                motion = motion_info["motion"]
-                max_motion = max(
-                    np.max(np.abs(motion.displacement[seg_index])) for seg_index in range(len(motion.displacement))
-                )
-                merging_params["max_distance_um"] = max(50, 2 * max_motion)
 
             # peak_sign = params['detection'].get('peak_sign', 'neg')
             # best_amplitudes = get_template_extremum_amplitude(templates, peak_sign=peak_sign)
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index c1e713b261..f22663d214 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -13,7 +13,10 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "verbose": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
-        "similarity_correlograms_kwargs": None,
+        "similarity_correlograms_kwargs": {"unit_locations_kwargs" : {
+                                "max_distance_um": 50, 
+                                "unit_locations" : {"method" : "monopolar_triangulation"}}
+                                },
         "temporal_splits_kwargs": None,
     }
 
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 6704cf496c..b0333e553d 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -13,6 +13,9 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "verbose": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
+        "unit_locations_kwargs": { "max_distance_um": 50, 
+                                   "unit_locations" : {"method" : "monopolar_triangulation"}
+                                },
         "template_diff_thresh": np.arange(0, 0.5, 0.05),
         "x_contaminations_kwargs": None,
     }
@@ -26,7 +29,11 @@ def __init__(self, sorting_analyzer, kwargs):
 
     def run(self, **job_kwargs):
         presets = ["x_contaminations"] * len(self.iterations)
-        params = [{"template_similarity_kwargs": {"template_diff_thresh": i}} for i in self.iterations]
+        params = []
+        for i in self.iterations:
+            local_param = {"unit_locations_kwargs" : self.params["unit_locations_kwargs"].copy()}
+            local_param["template_similarity_kwargs"] = {"template_diff_thresh": i}
+            params += [local_param]
         merging_kwargs = self.params["merging_kwargs"] or dict()
         analyzer = iterative_merges(
             self.analyzer,

From 44b3e05fc6b5d67893a8288124457362c94f543c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 19:22:16 +0000
Subject: [PATCH 147/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 7 +++----
 src/spikeinterface/sortingcomponents/merging/lussac.py | 6 ++----
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index f22663d214..2a9dece711 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -13,10 +13,9 @@ class CircusMerging(BaseMergingEngine):
     default_params = {
         "verbose": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
-        "similarity_correlograms_kwargs": {"unit_locations_kwargs" : {
-                                "max_distance_um": 50, 
-                                "unit_locations" : {"method" : "monopolar_triangulation"}}
-                                },
+        "similarity_correlograms_kwargs": {
+            "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}}
+        },
         "temporal_splits_kwargs": None,
     }
 
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index b0333e553d..43b2177b28 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -13,9 +13,7 @@ class LussacMerging(BaseMergingEngine):
     default_params = {
         "verbose": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
-        "unit_locations_kwargs": { "max_distance_um": 50, 
-                                   "unit_locations" : {"method" : "monopolar_triangulation"}
-                                },
+        "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
         "template_diff_thresh": np.arange(0, 0.5, 0.05),
         "x_contaminations_kwargs": None,
     }
@@ -31,7 +29,7 @@ def run(self, **job_kwargs):
         presets = ["x_contaminations"] * len(self.iterations)
         params = []
         for i in self.iterations:
-            local_param = {"unit_locations_kwargs" : self.params["unit_locations_kwargs"].copy()}
+            local_param = {"unit_locations_kwargs": self.params["unit_locations_kwargs"].copy()}
             local_param["template_similarity_kwargs"] = {"template_diff_thresh": i}
             params += [local_param]
         merging_kwargs = self.params["merging_kwargs"] or dict()

From 67526f5386eb6b5a02de2f719071c41ce3e44cad Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 21:33:44 +0200
Subject: [PATCH 148/164] Propagating job kwargs

---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index e914f60aad..3eaab13da7 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -206,7 +206,7 @@ def auto_merges(
                     if step in _templates_needed:
                         template_ext = sorting_analyzer.get_extension("templates")
                         if template_ext is None:
-                            sorting_analyzer.compute(["random_spikes", "templates"])
+                            sorting_analyzer.compute(["random_spikes", "templates"], **job_kwargs)
                     params = eval(f"{step}_kwargs")
                     params = params.get(ext, dict())
                     sorting_analyzer.compute(ext, **params, **job_kwargs)

From 7ebabe12687cea12caa9ebfebbb5abe8a6a0cfff Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Wed, 17 Jul 2024 22:19:58 +0200
Subject: [PATCH 149/164] Debugging and trying old analyzers

---
 .../sortingcomponents/merging/circus.py        |  7 ++++---
 .../sortingcomponents/merging/lussac.py        | 18 +++++++++++-------
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 2a9dece711..7bcfb5626a 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -12,7 +12,8 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
+        "compute_needed_extensions" : True,
+        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "similarity_correlograms_kwargs": {
             "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}}
         },
@@ -23,7 +24,6 @@ def __init__(self, sorting_analyzer, kwargs):
         self.params = self.default_params.copy()
         self.params.update(**kwargs)
         self.analyzer = sorting_analyzer
-        self.verbose = self.params["verbose"]
 
     def run(self, **job_kwargs):
         presets = ["similarity_correlograms", "temporal_splits"]
@@ -34,7 +34,8 @@ def run(self, **job_kwargs):
             self.analyzer,
             presets=presets,
             params=params,
-            verbose=self.verbose,
+            verbose=self.params["verbose"],
+            compute_needed_extensions=self.params["compute_needed_extensions"],
             merging_kwargs=self.params["merging_kwargs"],
             **job_kwargs,
         )
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 43b2177b28..4a7f45a5da 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,10 +12,13 @@ class LussacMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0.25, "censor_ms": 3},
-        "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
+        "compute_needed_extensions" : True,
+        "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "template_diff_thresh": np.arange(0, 0.5, 0.05),
-        "x_contaminations_kwargs": None,
+        "x_contaminations_kwargs": {"unit_locations_kwargs": {
+                        "max_distance_um": 50, 
+                        "unit_locations": {"method": "monopolar_triangulation"}}
+        }
     }
 
     def __init__(self, sorting_analyzer, kwargs):
@@ -29,16 +32,17 @@ def run(self, **job_kwargs):
         presets = ["x_contaminations"] * len(self.iterations)
         params = []
         for i in self.iterations:
-            local_param = {"unit_locations_kwargs": self.params["unit_locations_kwargs"].copy()}
+            local_param = self.params["x_contaminations_kwargs"].copy()
             local_param["template_similarity_kwargs"] = {"template_diff_thresh": i}
             params += [local_param]
-        merging_kwargs = self.params["merging_kwargs"] or dict()
+
         analyzer = iterative_merges(
             self.analyzer,
             presets=presets,
             params=params,
-            verbose=self.verbose,
-            merging_kwargs=merging_kwargs,
+            verbose=self.params["verbose"],
+            compute_needed_extensions=self.params["compute_needed_extensions"],
+            merging_kwargs=self.params["merging_kwargs"],
             **job_kwargs,
         )
         return analyzer.sorting

From 0134d0d2767f50b0aa0ffe14fb5f29d24ae6de6f Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 17 Jul 2024 20:20:31 +0000
Subject: [PATCH 150/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/circus.py | 2 +-
 src/spikeinterface/sortingcomponents/merging/lussac.py | 9 ++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 7bcfb5626a..4208bb056f 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -12,7 +12,7 @@ class CircusMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "compute_needed_extensions" : True,
+        "compute_needed_extensions": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "similarity_correlograms_kwargs": {
             "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}}
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 4a7f45a5da..1e5eef8c40 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -12,13 +12,12 @@ class LussacMerging(BaseMergingEngine):
 
     default_params = {
         "verbose": True,
-        "compute_needed_extensions" : True,
+        "compute_needed_extensions": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "template_diff_thresh": np.arange(0, 0.5, 0.05),
-        "x_contaminations_kwargs": {"unit_locations_kwargs": {
-                        "max_distance_um": 50, 
-                        "unit_locations": {"method": "monopolar_triangulation"}}
-        }
+        "x_contaminations_kwargs": {
+            "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}}
+        },
     }
 
     def __init__(self, sorting_analyzer, kwargs):

From 5c327fe20039d4ea14e856f67a2ed67373e9ac47 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 18 Jul 2024 10:04:16 +0200
Subject: [PATCH 151/164] WIP

---
 src/spikeinterface/curation/auto_merge.py     | 38 ++++++++++++++-----
 .../benchmark/benchmark_merging.py            |  4 +-
 .../sortingcomponents/merging/circus.py       | 17 ++++++---
 .../sortingcomponents/merging/lussac.py       | 26 +++++++------
 .../sortingcomponents/merging/main.py         |  3 +-
 5 files changed, 59 insertions(+), 29 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 3eaab13da7..c4823f721a 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -537,6 +537,7 @@ def iterative_merges(
     merging_kwargs={"merging_mode": "soft", "sparsity_overlap": 0.5, "censor_ms": 3},
     compute_needed_extensions=True,
     verbose=False,
+    extra_outputs=False,
     **job_kwargs,
 ):
     if params is None:
@@ -544,22 +545,39 @@ def iterative_merges(
 
     assert len(presets) == len(params)
 
+    if extra_outputs:
+        all_merges = []
+        all_outs = []
+
     for i in range(len(presets)):
-        merges = auto_merges(
-            sorting_analyzer,
-            preset=presets[i],
-            resolve_graph=True,
-            compute_needed_extensions=compute_needed_extensions * (i == 0),
-            extra_outputs=False,
-            **params[i],
-            **job_kwargs,
-        )
+        
+        result = auto_merges(
+                sorting_analyzer,
+                preset=presets[i],
+                resolve_graph=True,
+                compute_needed_extensions=compute_needed_extensions * (i == 0),
+                extra_outputs=extra_outputs,
+                **params[i],
+                **job_kwargs,
+            )
+
+        if extra_outputs:
+            merges = result[0]
+            all_merges += [merges]
+            all_outs += [result[1]]
+        else:
+            merges = result
+
         if verbose:
             n_merges = int(np.sum([len(i) for i in merges]))
             print(f"{n_merges} merges have been made during pass", presets[i])
 
         sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_kwargs, **job_kwargs)
-    return sorting_analyzer
+    
+    if extra_outputs:
+        return sorting_analyzer, all_merges, all_outs
+    else:
+        return sorting_analyzer
 
 
 def get_pairs_via_nntree(sorting_analyzer, k_nn=5, pair_mask=None, **knn_kwargs):
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 27d7db3e70..20908c0860 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -25,10 +25,12 @@ def __init__(self, recording, splitted_sorting, params, gt_sorting, splitted_cel
         self.result = {}
 
     def run(self, **job_kwargs):
-        self.result["sorting"] = merge_spikes(
+        self.result["sorting"], self.result["merges"], self.result["outs"] = merge_spikes(
             self.recording,
             self.splitted_sorting,
             method=self.method,
+            verbose=True, 
+            extra_outputs=True,
             method_kwargs=self.method_kwargs,
         )
 
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 4208bb056f..35389f6cb5 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -11,11 +11,11 @@ class CircusMerging(BaseMergingEngine):
     """
 
     default_params = {
-        "verbose": True,
         "compute_needed_extensions": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "similarity_correlograms_kwargs": {
-            "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}}
+            "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
+            #"template_similarity_kwargs": {"template_diff_thresh": 0.25, "template_similarity": {"method": "cosine", "max_lag_ms" : 0}}
         },
         "temporal_splits_kwargs": None,
     }
@@ -25,18 +25,23 @@ def __init__(self, sorting_analyzer, kwargs):
         self.params.update(**kwargs)
         self.analyzer = sorting_analyzer
 
-    def run(self, **job_kwargs):
+    def run(self, extra_outputs=False, verbose=False,  **job_kwargs):
         presets = ["similarity_correlograms", "temporal_splits"]
         similarity_kwargs = self.params["similarity_correlograms_kwargs"] or dict()
         temporal_kwargs = self.params["temporal_splits_kwargs"] or dict()
         params = [similarity_kwargs, temporal_kwargs]
-        analyzer = iterative_merges(
+        result = iterative_merges(
             self.analyzer,
             presets=presets,
             params=params,
-            verbose=self.params["verbose"],
+            verbose=verbose,
+            extra_outputs=extra_outputs,
             compute_needed_extensions=self.params["compute_needed_extensions"],
             merging_kwargs=self.params["merging_kwargs"],
             **job_kwargs,
         )
-        return analyzer.sorting
+        if extra_outputs:
+            return result[0].sorting, result[1], result[2]
+        else:
+            return result.sorting
+        
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 1e5eef8c40..8e6ec5233e 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -11,37 +11,41 @@ class LussacMerging(BaseMergingEngine):
     """
 
     default_params = {
-        "verbose": True,
-        "compute_needed_extensions": True,
+        "compute_needed_extensions" : True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
-        "template_diff_thresh": np.arange(0, 0.5, 0.05),
+        "template_diff_thresh": np.arange(0.05, 0.5, 0.05),
         "x_contaminations_kwargs": {
-            "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}}
-        },
+                "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
+                "template_similarity_kwargs": {}
+                #"template_similarity_kwargs": {"template_similarity": {"method": "cosine", "max_lag_ms" : 0}}
+        }
     }
 
     def __init__(self, sorting_analyzer, kwargs):
         self.params = self.default_params.copy()
         self.params.update(**kwargs)
         self.analyzer = sorting_analyzer
-        self.verbose = self.params["verbose"]
         self.iterations = self.params["template_diff_thresh"]
 
-    def run(self, **job_kwargs):
+    def run(self, extra_outputs=False, verbose=False, **job_kwargs):
         presets = ["x_contaminations"] * len(self.iterations)
         params = []
         for i in self.iterations:
             local_param = self.params["x_contaminations_kwargs"].copy()
-            local_param["template_similarity_kwargs"] = {"template_diff_thresh": i}
+            local_param["template_similarity_kwargs"].update({"template_diff_thresh": i})
             params += [local_param]
 
-        analyzer = iterative_merges(
+        result = iterative_merges(
             self.analyzer,
             presets=presets,
             params=params,
-            verbose=self.params["verbose"],
+            verbose=verbose,
+            extra_outputs=extra_outputs,
             compute_needed_extensions=self.params["compute_needed_extensions"],
             merging_kwargs=self.params["merging_kwargs"],
             **job_kwargs,
         )
-        return analyzer.sorting
+        if extra_outputs:
+            return result[0].sorting, result[1], result[2]
+        else:
+            return result.sorting
diff --git a/src/spikeinterface/sortingcomponents/merging/main.py b/src/spikeinterface/sortingcomponents/merging/main.py
index ec70f2418e..4c58175df8 100644
--- a/src/spikeinterface/sortingcomponents/merging/main.py
+++ b/src/spikeinterface/sortingcomponents/merging/main.py
@@ -35,6 +35,7 @@ def merge_spikes(
     templates=None,
     remove_empty=True,
     method_kwargs={},
+    extra_outputs=False,
     verbose=False,
     **job_kwargs,
 ):
@@ -76,7 +77,7 @@ def merge_spikes(
 
     method_instance = method_class(sorting_analyzer, method_kwargs)
 
-    return method_instance.run(**job_kwargs)
+    return method_instance.run(extra_outputs=extra_outputs, verbose=verbose, **job_kwargs)
 
 
 # generic class for template engine

From b88909d2efd280cb9ceddd0b78267b266bd7eb0f Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 18 Jul 2024 10:43:25 +0200
Subject: [PATCH 152/164] Allowing extra_outputs

---
 src/spikeinterface/curation/auto_merge.py     | 35 +++++++++++--------
 .../sortingcomponents/merging/circus.py       | 24 +++++++------
 .../sortingcomponents/merging/lussac.py       | 28 +++++++--------
 3 files changed, 49 insertions(+), 38 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index c4823f721a..6ca277362d 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -551,22 +551,29 @@ def iterative_merges(
 
     for i in range(len(presets)):
         
-        result = auto_merges(
-                sorting_analyzer,
-                preset=presets[i],
-                resolve_graph=True,
-                compute_needed_extensions=compute_needed_extensions * (i == 0),
-                extra_outputs=extra_outputs,
-                **params[i],
-                **job_kwargs,
-            )
-
         if extra_outputs:
-            merges = result[0]
+            merges, outs = auto_merges(
+                    sorting_analyzer,
+                    preset=presets[i],
+                    resolve_graph=True,
+                    compute_needed_extensions=compute_needed_extensions * (i == 0),
+                    extra_outputs=extra_outputs,
+                    **params[i],
+                    **job_kwargs,
+                )
+
             all_merges += [merges]
-            all_outs += [result[1]]
-        else:
-            merges = result
+            all_outs += [outs]
+        else:            
+            merges = auto_merges(
+                    sorting_analyzer,
+                    preset=presets[i],
+                    resolve_graph=True,
+                    compute_needed_extensions=compute_needed_extensions * (i == 0),
+                    extra_outputs=extra_outputs,
+                    **params[i],
+                    **job_kwargs,
+                )
 
         if verbose:
             n_merges = int(np.sum([len(i) for i in merges]))
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index 35389f6cb5..cdc6e76ea9 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -15,7 +15,7 @@ class CircusMerging(BaseMergingEngine):
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "similarity_correlograms_kwargs": {
             "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
-            #"template_similarity_kwargs": {"template_diff_thresh": 0.25, "template_similarity": {"method": "cosine", "max_lag_ms" : 0}}
+            "template_similarity_kwargs": {"template_diff_thresh": 0.25, "template_similarity": {"method": "cosine", "max_lag_ms" : 0.1}}
         },
         "temporal_splits_kwargs": None,
     }
@@ -30,18 +30,22 @@ def run(self, extra_outputs=False, verbose=False,  **job_kwargs):
         similarity_kwargs = self.params["similarity_correlograms_kwargs"] or dict()
         temporal_kwargs = self.params["temporal_splits_kwargs"] or dict()
         params = [similarity_kwargs, temporal_kwargs]
+
         result = iterative_merges(
-            self.analyzer,
-            presets=presets,
-            params=params,
-            verbose=verbose,
-            extra_outputs=extra_outputs,
-            compute_needed_extensions=self.params["compute_needed_extensions"],
-            merging_kwargs=self.params["merging_kwargs"],
-            **job_kwargs,
-        )
+                self.analyzer,
+                presets=presets,
+                params=params,
+                verbose=verbose,
+                extra_outputs=extra_outputs,
+                compute_needed_extensions=self.params["compute_needed_extensions"],
+                merging_kwargs=self.params["merging_kwargs"],
+                **job_kwargs,
+            )
+        
         if extra_outputs:
             return result[0].sorting, result[1], result[2]
         else:
             return result.sorting
         
+
+        
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 8e6ec5233e..d0b8cce0af 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -16,8 +16,7 @@ class LussacMerging(BaseMergingEngine):
         "template_diff_thresh": np.arange(0.05, 0.5, 0.05),
         "x_contaminations_kwargs": {
                 "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
-                "template_similarity_kwargs": {}
-                #"template_similarity_kwargs": {"template_similarity": {"method": "cosine", "max_lag_ms" : 0}}
+                "template_similarity_kwargs": {"template_similarity": {"method": "cosine", "max_lag_ms" : 0.1}}
         }
     }
 
@@ -30,22 +29,23 @@ def __init__(self, sorting_analyzer, kwargs):
     def run(self, extra_outputs=False, verbose=False, **job_kwargs):
         presets = ["x_contaminations"] * len(self.iterations)
         params = []
-        for i in self.iterations:
+        for thresh in self.iterations:
             local_param = self.params["x_contaminations_kwargs"].copy()
-            local_param["template_similarity_kwargs"].update({"template_diff_thresh": i})
+            local_param["template_similarity_kwargs"].update({"template_diff_thresh": thresh})
             params += [local_param]
 
         result = iterative_merges(
-            self.analyzer,
-            presets=presets,
-            params=params,
-            verbose=verbose,
-            extra_outputs=extra_outputs,
-            compute_needed_extensions=self.params["compute_needed_extensions"],
-            merging_kwargs=self.params["merging_kwargs"],
-            **job_kwargs,
-        )
+                self.analyzer,
+                presets=presets,
+                params=params,
+                verbose=verbose,
+                extra_outputs=extra_outputs,
+                compute_needed_extensions=self.params["compute_needed_extensions"],
+                merging_kwargs=self.params["merging_kwargs"],
+                **job_kwargs,
+            )
+
         if extra_outputs:
             return result[0].sorting, result[1], result[2]
         else:
-            return result.sorting
+            return result.sorting
\ No newline at end of file

From 15934aa6db1e2618b00dc2ac4a52da057de3b0e2 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 18 Jul 2024 08:45:30 +0000
Subject: [PATCH 153/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py     | 38 +++++++++----------
 .../benchmark/benchmark_merging.py            |  2 +-
 .../sortingcomponents/merging/circus.py       | 30 +++++++--------
 .../sortingcomponents/merging/lussac.py       | 28 +++++++-------
 4 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 6ca277362d..736facf4a5 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -550,37 +550,37 @@ def iterative_merges(
         all_outs = []
 
     for i in range(len(presets)):
-        
+
         if extra_outputs:
             merges, outs = auto_merges(
-                    sorting_analyzer,
-                    preset=presets[i],
-                    resolve_graph=True,
-                    compute_needed_extensions=compute_needed_extensions * (i == 0),
-                    extra_outputs=extra_outputs,
-                    **params[i],
-                    **job_kwargs,
-                )
+                sorting_analyzer,
+                preset=presets[i],
+                resolve_graph=True,
+                compute_needed_extensions=compute_needed_extensions * (i == 0),
+                extra_outputs=extra_outputs,
+                **params[i],
+                **job_kwargs,
+            )
 
             all_merges += [merges]
             all_outs += [outs]
-        else:            
+        else:
             merges = auto_merges(
-                    sorting_analyzer,
-                    preset=presets[i],
-                    resolve_graph=True,
-                    compute_needed_extensions=compute_needed_extensions * (i == 0),
-                    extra_outputs=extra_outputs,
-                    **params[i],
-                    **job_kwargs,
-                )
+                sorting_analyzer,
+                preset=presets[i],
+                resolve_graph=True,
+                compute_needed_extensions=compute_needed_extensions * (i == 0),
+                extra_outputs=extra_outputs,
+                **params[i],
+                **job_kwargs,
+            )
 
         if verbose:
             n_merges = int(np.sum([len(i) for i in merges]))
             print(f"{n_merges} merges have been made during pass", presets[i])
 
         sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_kwargs, **job_kwargs)
-    
+
     if extra_outputs:
         return sorting_analyzer, all_merges, all_outs
     else:
diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 20908c0860..16d16818a7 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -29,7 +29,7 @@ def run(self, **job_kwargs):
             self.recording,
             self.splitted_sorting,
             method=self.method,
-            verbose=True, 
+            verbose=True,
             extra_outputs=True,
             method_kwargs=self.method_kwargs,
         )
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index cdc6e76ea9..d2f124c8d1 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -15,7 +15,10 @@ class CircusMerging(BaseMergingEngine):
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "similarity_correlograms_kwargs": {
             "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
-            "template_similarity_kwargs": {"template_diff_thresh": 0.25, "template_similarity": {"method": "cosine", "max_lag_ms" : 0.1}}
+            "template_similarity_kwargs": {
+                "template_diff_thresh": 0.25,
+                "template_similarity": {"method": "cosine", "max_lag_ms": 0.1},
+            },
         },
         "temporal_splits_kwargs": None,
     }
@@ -25,27 +28,24 @@ def __init__(self, sorting_analyzer, kwargs):
         self.params.update(**kwargs)
         self.analyzer = sorting_analyzer
 
-    def run(self, extra_outputs=False, verbose=False,  **job_kwargs):
+    def run(self, extra_outputs=False, verbose=False, **job_kwargs):
         presets = ["similarity_correlograms", "temporal_splits"]
         similarity_kwargs = self.params["similarity_correlograms_kwargs"] or dict()
         temporal_kwargs = self.params["temporal_splits_kwargs"] or dict()
         params = [similarity_kwargs, temporal_kwargs]
 
         result = iterative_merges(
-                self.analyzer,
-                presets=presets,
-                params=params,
-                verbose=verbose,
-                extra_outputs=extra_outputs,
-                compute_needed_extensions=self.params["compute_needed_extensions"],
-                merging_kwargs=self.params["merging_kwargs"],
-                **job_kwargs,
-            )
-        
+            self.analyzer,
+            presets=presets,
+            params=params,
+            verbose=verbose,
+            extra_outputs=extra_outputs,
+            compute_needed_extensions=self.params["compute_needed_extensions"],
+            merging_kwargs=self.params["merging_kwargs"],
+            **job_kwargs,
+        )
+
         if extra_outputs:
             return result[0].sorting, result[1], result[2]
         else:
             return result.sorting
-        
-
-        
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index d0b8cce0af..30d634dd6c 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -11,13 +11,13 @@ class LussacMerging(BaseMergingEngine):
     """
 
     default_params = {
-        "compute_needed_extensions" : True,
+        "compute_needed_extensions": True,
         "merging_kwargs": {"merging_mode": "soft", "sparsity_overlap": 0, "censor_ms": 3},
         "template_diff_thresh": np.arange(0.05, 0.5, 0.05),
         "x_contaminations_kwargs": {
-                "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
-                "template_similarity_kwargs": {"template_similarity": {"method": "cosine", "max_lag_ms" : 0.1}}
-        }
+            "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
+            "template_similarity_kwargs": {"template_similarity": {"method": "cosine", "max_lag_ms": 0.1}},
+        },
     }
 
     def __init__(self, sorting_analyzer, kwargs):
@@ -35,17 +35,17 @@ def run(self, extra_outputs=False, verbose=False, **job_kwargs):
             params += [local_param]
 
         result = iterative_merges(
-                self.analyzer,
-                presets=presets,
-                params=params,
-                verbose=verbose,
-                extra_outputs=extra_outputs,
-                compute_needed_extensions=self.params["compute_needed_extensions"],
-                merging_kwargs=self.params["merging_kwargs"],
-                **job_kwargs,
-            )
+            self.analyzer,
+            presets=presets,
+            params=params,
+            verbose=verbose,
+            extra_outputs=extra_outputs,
+            compute_needed_extensions=self.params["compute_needed_extensions"],
+            merging_kwargs=self.params["merging_kwargs"],
+            **job_kwargs,
+        )
 
         if extra_outputs:
             return result[0].sorting, result[1], result[2]
         else:
-            return result.sorting
\ No newline at end of file
+            return result.sorting

From e15c676d4449bedb274ef145bcba5f3fab89509a Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 18 Jul 2024 11:04:15 +0200
Subject: [PATCH 154/164] Bugs

---
 .../sortingcomponents/benchmark/benchmark_merging.py        | 2 +-
 src/spikeinterface/sortingcomponents/merging/lussac.py      | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
index 20908c0860..9e97ce7d75 100644
--- a/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
+++ b/src/spikeinterface/sortingcomponents/benchmark/benchmark_merging.py
@@ -39,7 +39,7 @@ def compute_result(self, **result_params):
         comp = compare_sorter_to_ground_truth(self.gt_sorting, sorting, exhaustive_gt=True)
         self.result["gt_comparison"] = comp
 
-    _run_key_saved = [("sorting", "sorting"), ("merges", "pickle")]
+    _run_key_saved = [("sorting", "sorting"), ("merges", "pickle"), ("outs", "pickle")]
     _result_key_saved = [("gt_comparison", "pickle")]
 
 
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index d0b8cce0af..6a5898ec9a 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 import numpy as np
-
+import copy
 from .main import BaseMergingEngine
 from spikeinterface.curation.auto_merge import iterative_merges
 
@@ -30,8 +30,8 @@ def run(self, extra_outputs=False, verbose=False, **job_kwargs):
         presets = ["x_contaminations"] * len(self.iterations)
         params = []
         for thresh in self.iterations:
-            local_param = self.params["x_contaminations_kwargs"].copy()
-            local_param["template_similarity_kwargs"].update({"template_diff_thresh": thresh})
+            local_param = copy.deepcopy(self.params["x_contaminations_kwargs"])
+            local_param["template_similarity_kwargs"].update({"template_diff_thresh" : thresh})
             params += [local_param]
 
         result = iterative_merges(

From c3f11aaa89b4a7d9e835abc033e7e2851a2403a6 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 18 Jul 2024 09:06:52 +0000
Subject: [PATCH 155/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/sortingcomponents/merging/lussac.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 7a1f927c4b..22ced0817f 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -31,7 +31,7 @@ def run(self, extra_outputs=False, verbose=False, **job_kwargs):
         params = []
         for thresh in self.iterations:
             local_param = copy.deepcopy(self.params["x_contaminations_kwargs"])
-            local_param["template_similarity_kwargs"].update({"template_diff_thresh" : thresh})
+            local_param["template_similarity_kwargs"].update({"template_diff_thresh": thresh})
             params += [local_param]
 
         result = iterative_merges(

From 787d3a17f864edb0a3d442d164ace957e8488001 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 18 Jul 2024 11:42:47 +0200
Subject: [PATCH 156/164] Docs

---
 src/spikeinterface/curation/auto_merge.py     | 29 +++++++++++++++++++
 .../sortingcomponents/merging/circus.py       |  2 +-
 .../sortingcomponents/merging/lussac.py       |  2 +-
 3 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 736facf4a5..0dbdfa08dd 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -540,6 +540,35 @@ def iterative_merges(
     extra_outputs=False,
     **job_kwargs,
 ):
+    """
+    Wrapper to conveniently be able to launch several presets for auto_merges in a row, as a list. Merges
+    are applied sequentially, one preset at a time, and extensions are not recomputed thanks to the merging units
+
+    Parameters
+    ----------
+    sorting_analyzer : SortingAnalyzer
+        The SortingAnalyzer
+    presets : list of presets for the auto_merges() functions. Presets can be in    
+            "similarity_correlograms" | "x_contaminations" | "temporal_splits" | "feature_neighbors"
+            (see auto_merge for more details)
+    params : list of params that should be given to all presets. Should have the same length as presets
+    merging_kwargs : dict, the paramaters that should be used while merging units after each preset
+    compute_needed_extensions  : bool, default True
+            During the preset, boolean to specify is extensions needed by the steps should be recomputed, 
+            or used as they are if already present in the sorting_analyzer
+    extra_outputs : bool, default: False
+        If True, additional list of merges applied at every preset, and dictionary (`outs`) with processed data are returned.
+
+    Returns
+    -------
+    sorting_analyzer:
+        The new sorting analyzer where all the merges from all the presets have been applied
+    
+    merges, outs:
+        Returned only when extra_outputs=True
+        A list with all the merges performed at every steps, and dictionaries that contains data for debugging and plotting.
+    """
+    
     if params is None:
         params = [{}] * len(presets)
 
diff --git a/src/spikeinterface/sortingcomponents/merging/circus.py b/src/spikeinterface/sortingcomponents/merging/circus.py
index d2f124c8d1..7866a82fe0 100644
--- a/src/spikeinterface/sortingcomponents/merging/circus.py
+++ b/src/spikeinterface/sortingcomponents/merging/circus.py
@@ -17,7 +17,7 @@ class CircusMerging(BaseMergingEngine):
             "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
             "template_similarity_kwargs": {
                 "template_diff_thresh": 0.25,
-                "template_similarity": {"method": "cosine", "max_lag_ms": 0.1},
+                "template_similarity": {"method": "l2", "max_lag_ms": 0.1},
             },
         },
         "temporal_splits_kwargs": None,
diff --git a/src/spikeinterface/sortingcomponents/merging/lussac.py b/src/spikeinterface/sortingcomponents/merging/lussac.py
index 7a1f927c4b..3c853e7c3b 100644
--- a/src/spikeinterface/sortingcomponents/merging/lussac.py
+++ b/src/spikeinterface/sortingcomponents/merging/lussac.py
@@ -16,7 +16,7 @@ class LussacMerging(BaseMergingEngine):
         "template_diff_thresh": np.arange(0.05, 0.5, 0.05),
         "x_contaminations_kwargs": {
             "unit_locations_kwargs": {"max_distance_um": 50, "unit_locations": {"method": "monopolar_triangulation"}},
-            "template_similarity_kwargs": {"template_similarity": {"method": "cosine", "max_lag_ms": 0.1}},
+            "template_similarity_kwargs": {"template_similarity": {"method": "l2", "max_lag_ms": 0.1}},
         },
     }
 

From 3a72d1dfeb1db477009aff53ccf482fe93c8a4d8 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 18 Jul 2024 09:43:22 +0000
Subject: [PATCH 157/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 0dbdfa08dd..93cf0b3604 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -548,13 +548,13 @@ def iterative_merges(
     ----------
     sorting_analyzer : SortingAnalyzer
         The SortingAnalyzer
-    presets : list of presets for the auto_merges() functions. Presets can be in    
+    presets : list of presets for the auto_merges() functions. Presets can be in
             "similarity_correlograms" | "x_contaminations" | "temporal_splits" | "feature_neighbors"
             (see auto_merge for more details)
     params : list of params that should be given to all presets. Should have the same length as presets
     merging_kwargs : dict, the paramaters that should be used while merging units after each preset
     compute_needed_extensions  : bool, default True
-            During the preset, boolean to specify is extensions needed by the steps should be recomputed, 
+            During the preset, boolean to specify is extensions needed by the steps should be recomputed,
             or used as they are if already present in the sorting_analyzer
     extra_outputs : bool, default: False
         If True, additional list of merges applied at every preset, and dictionary (`outs`) with processed data are returned.
@@ -563,12 +563,12 @@ def iterative_merges(
     -------
     sorting_analyzer:
         The new sorting analyzer where all the merges from all the presets have been applied
-    
+
     merges, outs:
         Returned only when extra_outputs=True
         A list with all the merges performed at every steps, and dictionaries that contains data for debugging and plotting.
     """
-    
+
     if params is None:
         params = [{}] * len(presets)
 

From ba9d9559fd570e1c5c8d481501b6dcc8d7aa83c9 Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Thu, 18 Jul 2024 14:00:23 +0200
Subject: [PATCH 158/164] Ease the view of final merges

---
 src/spikeinterface/curation/auto_merge.py | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 93cf0b3604..6fdedc046f 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -573,6 +573,7 @@ def iterative_merges(
         params = [{}] * len(presets)
 
     assert len(presets) == len(params)
+    n_units = max(sorting_analyzer.unit_ids) + 1
 
     if extra_outputs:
         all_merges = []
@@ -611,7 +612,19 @@ def iterative_merges(
         sorting_analyzer = sorting_analyzer.merge_units(merges, **merging_kwargs, **job_kwargs)
 
     if extra_outputs:
-        return sorting_analyzer, all_merges, all_outs
+
+        final_merges = {}
+        for merge in all_merges:
+            for count, m in enumerate(merge):
+                new_list = m
+                for k in m:
+                    if k in final_merges:
+                        new_list.remove(k)
+                        new_list += final_merges[k] 
+                final_merges[count + n_units] = new_list
+            n_units = max(final_merges.keys()) + 1
+
+        return sorting_analyzer, list(final_merges.values()), all_outs
     else:
         return sorting_analyzer
 

From b97f60aefbc4f5358193e5119d0f79e8279c01ca Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 18 Jul 2024 12:00:51 +0000
Subject: [PATCH 159/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 6fdedc046f..abb5e8baba 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -620,7 +620,7 @@ def iterative_merges(
                 for k in m:
                     if k in final_merges:
                         new_list.remove(k)
-                        new_list += final_merges[k] 
+                        new_list += final_merges[k]
                 final_merges[count + n_units] = new_list
             n_units = max(final_merges.keys()) + 1
 

From e1ef2a04864c4288ffe02ea273afbbbb86d91548 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Fri, 19 Jul 2024 09:11:12 +0200
Subject: [PATCH 160/164] Avoid erasing already computed extensions

---
 src/spikeinterface/curation/auto_merge.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index abb5e8baba..8f19df1b21 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -133,7 +133,7 @@ def auto_merges(
     https://github.com/BarbourLab/lussac/blob/v1.0.0/postprocessing/merge_units.py
     """
     import scipy
-
+    
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids
 
@@ -199,6 +199,10 @@ def auto_merges(
                 "quality_score",
             ]
 
+    if compute_needed_extensions:
+        # To avoid erasing the extensions of the user
+        sorting_analyzer = sorting_analyzer.copy()
+
     for step in steps:
         if step in _required_extensions:
             for ext in _required_extensions[step]:

From 10a1c78c49154f77d4424c51c2dbf0d2d73b0229 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 19 Jul 2024 07:14:24 +0000
Subject: [PATCH 161/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 8f19df1b21..d1af883e18 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -133,7 +133,7 @@ def auto_merges(
     https://github.com/BarbourLab/lussac/blob/v1.0.0/postprocessing/merge_units.py
     """
     import scipy
-    
+
     sorting = sorting_analyzer.sorting
     unit_ids = sorting.unit_ids
 

From 970dd952cc1f3de819a94e97ad97ed7c554f6cbb Mon Sep 17 00:00:00 2001
From: Pierre Yger <pierre.yger@gmail.com>
Date: Fri, 19 Jul 2024 15:24:16 +0200
Subject: [PATCH 162/164] Force copy of the analyzer

---
 src/spikeinterface/curation/auto_merge.py | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index d1af883e18..5b4781df86 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -60,6 +60,7 @@ def auto_merges(
     compute_needed_extensions: bool = True,
     extra_outputs: bool = False,
     steps: list[str] | None = None,
+    force_copy : bool = True,
     **job_kwargs,
 ) -> list[tuple[int | str, int | str]] | Tuple[tuple[int | str, int | str], dict]:
     """
@@ -108,14 +109,18 @@ def auto_merges(
         If `preset` is None, you can specify the steps manually with the `steps` parameter.
     resolve_graph : bool, default: False
         If True, the function resolves the potential unit pairs to be merged into multiple-unit merges.
-
+    compute_needed_extensions : bool, default : True
+        Should we force the computation of needed extensions?
     extra_outputs : bool, default: False
         If True, an additional dictionary (`outs`) with processed data is returned.
     steps : None or list of str, default: None
         Which steps to run, if no preset is used.
         Pontential steps : "num_spikes", "snr", "remove_contaminated", "unit_locations", "correlogram",
         "template_similarity", "presence_distance", "cross_contamination", "knn", "quality_score"
-        Please check steps explanations above!
+        Please check steps explanations above!$
+    force_copy : boolean, default: True
+        When new extensions are computed, the default is to make a copy of the analyzer, to avoid overwriting
+        already computed extensions. False if you want to overwrite
 
     Returns
     -------
@@ -198,8 +203,7 @@ def auto_merges(
                 "knn",
                 "quality_score",
             ]
-
-    if compute_needed_extensions:
+    if force_copy and compute_needed_extensions:
         # To avoid erasing the extensions of the user
         sorting_analyzer = sorting_analyzer.copy()
 
@@ -579,19 +583,22 @@ def iterative_merges(
     assert len(presets) == len(params)
     n_units = max(sorting_analyzer.unit_ids) + 1
 
+    if compute_needed_extensions:
+        sorting_analyzer = sorting_analyzer.copy()
+
     if extra_outputs:
         all_merges = []
         all_outs = []
 
     for i in range(len(presets)):
-
         if extra_outputs:
             merges, outs = auto_merges(
                 sorting_analyzer,
                 preset=presets[i],
                 resolve_graph=True,
-                compute_needed_extensions=compute_needed_extensions * (i == 0),
+                compute_needed_extensions=bool(compute_needed_extensions * (i == 0)),
                 extra_outputs=extra_outputs,
+                force_copy=False,
                 **params[i],
                 **job_kwargs,
             )
@@ -605,6 +612,7 @@ def iterative_merges(
                 resolve_graph=True,
                 compute_needed_extensions=compute_needed_extensions * (i == 0),
                 extra_outputs=extra_outputs,
+                force_copy=False,
                 **params[i],
                 **job_kwargs,
             )
@@ -626,7 +634,8 @@ def iterative_merges(
                         new_list.remove(k)
                         new_list += final_merges[k]
                 final_merges[count + n_units] = new_list
-            n_units = max(final_merges.keys()) + 1
+            if len(final_merges.keys()) > 0:
+                n_units = max(final_merges.keys()) + 1
 
         return sorting_analyzer, list(final_merges.values()), all_outs
     else:

From 61fc29b86c2c0a8ba17082603bd6817740764e98 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 19 Jul 2024 13:24:39 +0000
Subject: [PATCH 163/164] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/spikeinterface/curation/auto_merge.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/curation/auto_merge.py b/src/spikeinterface/curation/auto_merge.py
index 5b4781df86..3aa94a4602 100644
--- a/src/spikeinterface/curation/auto_merge.py
+++ b/src/spikeinterface/curation/auto_merge.py
@@ -60,7 +60,7 @@ def auto_merges(
     compute_needed_extensions: bool = True,
     extra_outputs: bool = False,
     steps: list[str] | None = None,
-    force_copy : bool = True,
+    force_copy: bool = True,
     **job_kwargs,
 ) -> list[tuple[int | str, int | str]] | Tuple[tuple[int | str, int | str], dict]:
     """

From c9d673d8cc2676e946d03a37930ef39275fd2171 Mon Sep 17 00:00:00 2001
From: Sebastien <pierre.yger@gmail.com>
Date: Tue, 23 Jul 2024 12:29:52 +0200
Subject: [PATCH 164/164] Fixes

---
 src/spikeinterface/sorters/internal/spyking_circus2.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spikeinterface/sorters/internal/spyking_circus2.py b/src/spikeinterface/sorters/internal/spyking_circus2.py
index 6a8cbbd5a1..79313ef01b 100644
--- a/src/spikeinterface/sorters/internal/spyking_circus2.py
+++ b/src/spikeinterface/sorters/internal/spyking_circus2.py
@@ -32,7 +32,7 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
             "seed": 42,
         },
         "apply_motion_correction": True,
-        "motion_correction": {"preset": "nonrigid_fast_and_accurate"},
+        "motion_correction": {"preset": "dredge_fast"},
         "merging": {"method": "lussac"},
         "clustering": {"legacy": True},
         "matching": {"method": "wobble"},