ibl-neuropixel 1.9.0__py3-none-any.whl → 1.9.2__py3-none-any.whl

{ibl_neuropixel-1.9.0.dist-info → ibl_neuropixel-1.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibl-neuropixel
-Version: 1.9.0
+Version: 1.9.2
 Summary: Collection of tools for Neuropixel 1.0 and 2.0 probes data
 Home-page: https://github.com/int-brain-lab/ibl-neuropixel
 Author: The International Brain Laboratory
@@ -41,6 +41,53 @@ Minimum Python version supported is 3.10
 
 ## Destriping
 ### Getting started
+
+#### Compress a binary file losslessly using `mtscomp`
+
+The mtscomp util implements fast chunked compression for neurophysiology data in a single shard.
+Package repository is [here](https://github.com/int-brain-lab/mtscomp).
+
+
+```python
+from pathlib import Path
+import spikeglx
+file_spikeglx = Path('/datadisk/neuropixel/file.imec0.ap.bin')
+sr = spikeglx.Reader(file_spikeglx)
+sr.compress_file()
+# note: you can use sr.compress_file(keep_original=False) to also remove the orginal bin file
+```
+
+#### Reading raw spikeglx file and manipulating arrays
+
+The mtscomp util implements fast chunked compression for neurophysiology data in a single shard.
+Package repository is [here](https://github.com/int-brain-lab/mtscomp).
+
+```python
+from pathlib import Path
+import spikeglx
+
+import ibldsp.voltage
+
+file_spikeglx = Path('/datadisk/Data/neuropixel/human/Pt01.imec0.ap.bin')
+sr = spikeglx.Reader(file_spikeglx)
+
+# reads in 300ms of data
+raw = sr[10_300_000:10_310_000, :sr.nc - sr.nsync].T
+destripe = ibldsp.voltage.destripe(raw, fs=sr.fs, neuropixel_version=1)
+
+# display with matplotlib backend
+import ibldsp.plots
+ibldsp.plots.voltageshow(raw, fs=sr.fs, title='raw')
+ibldsp.plots.voltageshow(destripe, fs=sr.fs, title='destripe')
+
+# display with QT backend
+from viewephys.gui import viewephys
+eqc = {}
+eqc['raw'] = viewephys(raw, fs=sr.fs, title='raw')
+eqc['destripe'] = viewephys(destripe, fs=sr.fs, title='destripe')
+```
+
+#### Destripe a binary file
 This relies on a fast fourier transform external library: `pip install pyfftw`.
 
 Minimal working example to destripe a neuropixel binary file. 

{ibl_neuropixel-1.9.0.dist-info → ibl_neuropixel-1.9.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
 neuropixel.py,sha256=P7sIBAtGIqKReK7OqMBqdwPaTeHjhHMyfyBRL_AvuQY,37987
-spikeglx.py,sha256=LjTPcEnml23-NYbO_157QVIBheswJs6hS_MKIxZm8Ng,41035
-ibl_neuropixel-1.9.0.dist-info/licenses/LICENSE,sha256=JJCjBeS78UPiX7TZpE-FnMjNNpCyrFb4s8VDGG2wD10,1087
+spikeglx.py,sha256=4TPXnFGhJahClxr4fA9HwTeiiHBQS9ZEfkWl6t20q2s,41068
+ibl_neuropixel-1.9.2.dist-info/licenses/LICENSE,sha256=JJCjBeS78UPiX7TZpE-FnMjNNpCyrFb4s8VDGG2wD10,1087
 ibldsp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ibldsp/cadzow.py,sha256=pAtxDxBwoNhoxFNc2R5WLwUrmKsq4rQuaglRNgW2Lj8,7251
+ibldsp/cadzow.py,sha256=YVQdF1HAZEhdanGKSBt3FWUSd66_VCxN8y2eQy8q9Fc,7307
 ibldsp/cuda_tools.py,sha256=6LpVhYOCuOXEEg8kJ3aOCE4hzA1Yq1dojsbbBQmQCF4,2387
 ibldsp/destripe_gpu.py,sha256=I5jzFocpsYw36kMMd533YThbrQaZix5e1sHqsUjHvO4,2824
 ibldsp/filter_gpu.py,sha256=DPrPBLRXeCh_6BcJWJnPFaxS9Q6kX4nPENZg-c2q5rc,5789
@@ -12,24 +12,24 @@ ibldsp/plots.py,sha256=XmYC4yca_seZYNEmC5hE5wBiJAl_fi_KU00DbNcM6jI,4577
 ibldsp/raw_metrics.py,sha256=Ie4b7unuFc-XiFc9-tpTsUkph29G-20NvM7iJ25jAPI,5198
 ibldsp/smooth.py,sha256=m_mByXHG_JyFErnYsZ27gXjcqpfwCEuWa6eOb9eFuyg,8033
 ibldsp/spiketrains.py,sha256=lYP1PD4l6T-4KhFu8ZXlbnUUnEQLOriGxN1szacolPY,6878
-ibldsp/utils.py,sha256=7Mp3UrSz_dZKXH806YkPKI3UBLJ91kLr3NtSVTIg2kI,17795
-ibldsp/voltage.py,sha256=brxkaONTdNzwZnzhuSHTkt5KxOcPln5Axj780mNjZTg,45339
+ibldsp/utils.py,sha256=Ku1pdymbiCyQU5iZX8Akfq47YXM4xegW6G3_aomh6WA,18580
+ibldsp/voltage.py,sha256=Pb1ZYlr8av2XDUspZaSUtF2wOoTy92fnrsxnW9sTIFA,47708
 ibldsp/waveform_extraction.py,sha256=yKrldgHqpwQ_Dq6xdoSCceKkfrL9FUXnpwKJUM3R41M,26570
-ibldsp/waveforms.py,sha256=5OBLYuM902WS_9WGDDmiTh4BpYWGe7-bQYTMxc2mYII,35166
+ibldsp/waveforms.py,sha256=XKWO0sSEhZR1mBsXCdGpVU3ga96HX3CViXIgpl3bml8,35280
 neurowaveforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neurowaveforms/model.py,sha256=YOPWMMNNS_Op5TyK4Br1i9_Ni41jLSqHie5r1vb5VjY,6729
 tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/integration/csd_experiments.py,sha256=bddMl2SCzeEM_QnBrZGypUYMKxFVDc6qderyUyX-iew,3158
-tests/integration/test_destripe.py,sha256=6OwqWWz3hJSPGAeEGDcJJkG4bZMnNeaU80AlH7vyrno,6170
+tests/integration/test_destripe.py,sha256=ZV7gasuFib2AbVb63WczgQvc13PbIX9t4pQgamBMgRY,6161
 tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit/test_ephys_np2.py,sha256=1wsgS_C5W8tUO_qDyORBRUKGsrB0Gq3wMLAjJcjrNZ4,15599
 tests/unit/test_neuropixel.py,sha256=ZFKrvTYaYgK5WgOfoHa5x9BNUpRomACPiIm6Kr-A3gw,2511
 tests/unit/test_plots.py,sha256=PhCxrEN1Zd1jTgmiwd16_dEghcI7kwmHT3AQmAPpzkA,850
-tests/unit/test_spikeglx.py,sha256=4Bv9nGm7o1LorPPIeHAqfRdsxI56xIsyYotzTSRlt4Q,33296
-tests/unit/test_utils.py,sha256=lraYbOkpQ6us43cpEFq8mlrcKnea9uSUrBKtxoRKE3g,21861
-tests/unit/test_voltage.py,sha256=4vpOCBCrXlvXAG5MRPMTIjKSoYT0kapQxyN1s_7t7Ns,5198
+tests/unit/test_spikeglx.py,sha256=9PrSOPGrYAAQEeJPAOmqc3Rhgia6ftv-zihVWXglhqw,34388
+tests/unit/test_utils.py,sha256=37XQDUqcABYrrsdX17kX54H4e5jld7GOn1ISxtgoa5U,21859
+tests/unit/test_voltage.py,sha256=Nr6KqNGn2yOGPJYnvVzxdM5IiEHvK2FicDR_7fzvTHQ,6228
 tests/unit/test_waveforms.py,sha256=VnFvUi1pteROwwbC5Ebp2lqSxF3a8a7eXHpD8OUeuTg,16237
-ibl_neuropixel-1.9.0.dist-info/METADATA,sha256=KV0iSckmgwW_bMqNvgT1he4E6pEfZsSktYlxWWgJ-3A,2295
-ibl_neuropixel-1.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ibl_neuropixel-1.9.0.dist-info/top_level.txt,sha256=WtVcEUptnwU6BT72cgGmrWYFGM9d9qCEqe3LwR9FIw4,48
-ibl_neuropixel-1.9.0.dist-info/RECORD,,
+ibl_neuropixel-1.9.2.dist-info/METADATA,sha256=4RuLzmWxYJjEyYJKA_1Szi0T0Dn5-VRjD7o4BaY-mHQ,3746
+ibl_neuropixel-1.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ibl_neuropixel-1.9.2.dist-info/top_level.txt,sha256=WtVcEUptnwU6BT72cgGmrWYFGM9d9qCEqe3LwR9FIw4,48
+ibl_neuropixel-1.9.2.dist-info/RECORD,,

ibldsp/cadzow.py

@@ -17,6 +17,8 @@ for N-spatial dimensions.
 }
 """
 
+from functools import lru_cache
+
 import numpy as np
 import scipy.fft
 from iblutil.numerical import ismember2d
@@ -46,6 +48,7 @@ def traj_matrix_indices(n):
     return itraj
 
 
+@lru_cache(maxsize=24)
 def trajectory(x, y, dtype=np.complex128):
     """
     Computes the 2 spatial dimensions block-Toeplitz indices from x and y trace coordinates.

ibldsp/utils.py

@@ -89,7 +89,7 @@ def parabolic_max(x):
     # for 2D arrays, operate along the last dimension
     ns = x.shape[-1]
     axis = -1
-    imax = np.argmax(x, axis=axis)
+    imax = np.nanargmax(x, axis=axis)
 
     if x.ndim == 1:
         v010 = x[np.maximum(np.minimum(imax + np.array([-1, 0, 1]), ns - 1), 0)]
@@ -382,17 +382,36 @@ class WindowGenerator(object):
             amp[-self.overlap :] = 1 if last == self.ns else np.flipud(w)
             yield (first, last, amp)
 
+    @property
+    def first_last_valid_noedge(self):
+        """
+        Generator that yields a tuple of first, last, first_valid, last_valid index of windows
+        The valid indices span up to half of the overlap.
+        The first and last windows have respectively the beginning and end of the signal discarded.
+        :return:
+        """
+        return self._firstlast_valid(discard_edges=True)
+
     @property
     def firstlast_valid(self):
         """
         Generator that yields a tuple of first, last, first_valid, last_valid index of windows
-        The valid indices span up to half of the overlap
+        The valid indices span up to half of the overlap.
+        The first and last windows have the full beginning and end of the signal respectively.
+        To discard the beginning and end edges, use firstlast_valid_noedge instead.
         :return:
         """
+        return self._firstlast_valid(self)
+
+    def _firstlast_valid(self, discard_edges=False):
         assert self.overlap % 2 == 0, "Overlap must be even"
         for first, last in self.firstlast:
-            first_valid = 0 if first == 0 else first + self.overlap // 2
-            last_valid = last if last == self.ns else last - self.overlap // 2
+            first_valid = (
+                0 if first == 0 and discard_edges else first + self.overlap // 2
+            )
+            last_valid = (
+                last if last == self.ns and discard_edges else last - self.overlap // 2
+            )
             yield (first, last, first_valid, last_valid)
 
     @property

ibldsp/voltage.py

@@ -782,28 +782,67 @@ def decompress_destripe_cbin(
         np.save(
             output_qc_path.joinpath("_iblqc_ephysTimeRmsAP.timestamps.npy"), time_data
         )
-        np.save(
-            output_qc_path.joinpath("_iblqc_ephysSaturation.samples.npy"),
+        saturation_samples_to_intervals(
             saturation_data,
+            output_file=output_qc_path.joinpath("_iblqc_ephysSaturation.samples.pqt"),
         )
+        file_saturation.unlink()
 
 
 def detect_bad_channels(
-    raw, fs, similarity_threshold=(-0.5, 1), psd_hf_threshold=None, display=False
+    raw,
+    fs,
+    similarity_threshold=(-0.5, 1),
+    psd_hf_threshold=None,
+    display=False,
+    outside_threshold=-0.75,
 ):
     """
-    Bad channels detection for Neuropixel probes
-    Labels channels
-     0: all clear
-     1: dead low coherence / amplitude
-     2: noisy
-     3: outside of the brain
-    :param raw: [nc, ns]
-    :param fs: sampling frequency
-    :param similarity_threshold:
-    :param psd_hf_threshold:
-    :param display: optinal (False) will show a plot of features alongside a raw data snippet
-    :return: labels (numpy vector [nc]), xfeats: dictionary of features [nc]
+    Detect bad channels in Neuropixel probe recordings based on signal quality metrics.
+
+    This function analyzes raw electrophysiology data to identify and label problematic channels
+    using multiple criteria including cross-correlation with neighboring channels, power spectral
+    density analysis, and spatial coherence patterns. Channels are classified into four categories:
+    good (0), dead (1), noisy (2), or outside the brain (3).
+
+    Parameters
+    ----------
+    raw : numpy.ndarray
+        Raw voltage traces array with shape (nc, ns), where nc is the number of channels
+        and ns is the number of samples.
+    fs : float
+        Sampling frequency in Hz.
+    similarity_threshold : tuple of float, optional
+        Two-element tuple (lower, upper) defining the acceptable range for high-frequency
+        cross-correlation values. Channels outside this range are flagged as dead (below lower)
+        or noisy (above upper). Defaults to (-0.5, 1).
+    psd_hf_threshold : float, optional
+        Threshold for high-frequency power spectral density to identify noisy channels.
+        If None, defaults to 0.02 for AP band (fs > 2600 Hz) or 1.4 for LF band (fs <= 2600 Hz).
+        Units are µV²/Hz.
+    display : bool, optional
+        If True, displays a diagnostic plot showing channel features and a raw data snippet.
+        Defaults to False.
+    outside_threshold : float or str, optional
+        Threshold for low-frequency cross-correlation to identify channels outside the brain.
+        Can be a float value (default -0.75) or 'adaptive' for automatic threshold detection
+        based on signal gradient analysis.
+
+    Returns
+    -------
+    ichannels : numpy.ndarray
+        Integer array of shape (nc,) containing channel labels:
+        - 0: good channel
+        - 1: dead channel (low coherence/amplitude)
+        - 2: noisy channel (high noise or excessive correlation)
+        - 3: outside of the brain
+    xfeats : dict
+        Dictionary containing computed features for each channel:
+        - 'ind': channel indices
+        - 'rms_raw': RMS amplitude of raw signal
+        - 'xcor_hf': detrended high-frequency cross-correlation
+        - 'xcor_lf': low-frequency cross-correlation component
+        - 'psd_hf': mean power spectral density in high-frequency band
     """
 
     def rneighbours(raw, n=1):  # noqa
@@ -896,21 +935,28 @@ def detect_bad_channels(
     )[0]
     # the channels outside of the brains are the contiguous channels below the threshold on the trend coherency
 
-    signal_noisy = xfeats["xcor_lf"]
-    # Filter signal
-    window_size = 25  # Choose based on desired smoothing (e.g., 25 samples)
-    kernel = np.ones(window_size) / window_size
-    # Apply convolution
-    signal_filtered = np.convolve(signal_noisy, kernel, mode="same")
-
-    diff_x = np.diff(signal_filtered)
-    indx = np.where(diff_x < -0.02)[0]  # hardcoded threshold
-    if indx.size > 0:
-        indx_threshold = np.floor(np.median(indx)).astype(int)
-        threshold = signal_noisy[indx_threshold]
-        ioutside = np.where(signal_noisy < threshold)[0]
+    # deal with channels outside of the brain
+    if outside_threshold == "adaptive":
+        signal_noisy = xfeats["xcor_lf"]
+        # Filter signal
+        window_size = 25  # Choose based on desired smoothing (e.g., 25 samples)
+        kernel = np.ones(window_size) / window_size
+        # Apply convolution
+        signal_filtered = np.convolve(signal_noisy, kernel, mode="same")
+
+        diff_x = np.diff(signal_filtered)
+        indx = np.where(diff_x < -0.02)[0]  # hardcoded threshold
+        if indx.size > 0:
+            indx_threshold = np.floor(np.median(indx)).astype(int)
+            threshold = signal_noisy[indx_threshold]
+            ioutside = np.where(signal_noisy < threshold)[0]
+        else:
+            ioutside = np.array([])
     else:
-        ioutside = np.array([])
+        assert np.isreal(outside_threshold) and np.isscalar(outside_threshold), (
+            "outside_threshold must be a real number or 'adaptive' for adaptive threshold"
+        )
+        ioutside = np.where(xfeats["xcor_lf"] < outside_threshold)[0]
 
     if ioutside.size > 0 and ioutside[-1] == (nc - 1):
         a = np.cumsum(np.r_[0, np.diff(ioutside) - 1])

ibldsp/waveforms.py

@@ -297,7 +297,7 @@ def plot_wiggle(
     return ax
 
 
-def double_wiggle(wav, fs=1, ax=None, colors=None, **kwargs):
+def double_wiggle(wav, fs=1, ax=None, colors=None, title=None, **kwargs):
     """
     Double trouble: this wiggle colours both the negative and the postive values
     :param wav: (nchannels, nsamples)
@@ -308,6 +308,7 @@ def double_wiggle(wav, fs=1, ax=None, colors=None, **kwargs):
     :param fill_sign: -1 for negative (default for spikes), 1 for positive
     :param plot_kwargs: kwargs for the line plot
     :param fill_kwargs: kwargs for the fill
+    :param title: title for the axis (optional)
     :return:
     """
     if colors is None:
@@ -334,6 +335,8 @@ def double_wiggle(wav, fs=1, ax=None, colors=None, **kwargs):
         fill_kwargs={"color": colors[1]},
         **kwargs,
     )
+    if title is not None:
+        ax.set(title=title)
     return ax
 
 

spikeglx.py

@@ -144,11 +144,7 @@ class Reader:
         sglx_file = str(self.file_bin)
         if self.is_mtscomp:
             self._raw = mtscomp.Reader()
-            self.ch_file = (
-                _get_companion_file(sglx_file, ".ch")
-                if self.ch_file is None
-                else self.ch_file
-            )
+            self.ch_file = self._parse_ch_file()
             self._raw.open(self.file_bin, self.ch_file)
             if self._raw.shape != (self.ns, self.nc):
                 ftsec = self._raw.shape[0] / self.fs
@@ -396,10 +392,8 @@ class Reader:
         if "out" not in kwargs:
             kwargs["out"] = self.file_bin.with_suffix(".bin")
         assert self.is_mtscomp
-        if file_ch is None:
-            file_ch = self.file_bin.with_suffix(".ch")
-
-        r = mtscomp.decompress(self.file_bin, file_ch, **kwargs)
+        ch_file = self._parse_ch_file(file_ch)
+        r = mtscomp.decompress(self.file_bin, ch_file, **kwargs)
         r.close()
         if not keep_original:
             self.close()
@@ -420,9 +414,10 @@ class Reader:
             bin_file = Path(self.file_bin).with_suffix(".bin")
         else:
             scratch_dir.mkdir(exist_ok=True, parents=True)
-            bin_file = scratch_dir / Path(self.file_bin).with_suffix(".bin").name
-            file_meta_scratch = scratch_dir / file_meta.name
-            shutil.copy(self.file_meta_data, file_meta_scratch)
+            bin_file = (
+                Path(scratch_dir).joinpath(self.file_bin.name).with_suffix(".bin")
+            )
+            shutil.copy(self.file_meta_data, bin_file.parent / self.file_meta_data.name)
         if not bin_file.exists():
             t0 = time.time()
             _logger.info("File is compressed, decompressing to a temporary file...")
@@ -464,6 +459,12 @@ class Reader:
         log_func(f"SHA1 computed: {sc}")
         return sm == sc
 
+    def _parse_ch_file(self, ch_file=None):
+        ch_file = (
+            _get_companion_file(self.file_bin, ".ch") if ch_file is None else ch_file
+        )
+        return ch_file
+
 
 class OnlineReader(Reader):
     @property
@@ -999,7 +1000,7 @@ def _mock_spikeglx_file(
     meta_file,
     ns,
     nc,
-    sync_depth,
+    sync_depth=16,
     random=False,
     int2volts=0.6 / 32768,
     corrupt=False,

tests/integration/test_destripe.py

@@ -4,6 +4,7 @@ import logging
 import shutil
 import unittest
 from pathlib import Path
+import pandas as pd
 
 import neuropixel
 import spikeglx
@@ -84,11 +85,11 @@ class TestEphysSpikeSortingMultiProcess(unittest.TestCase):
             shutil.rmtree(self.file_path.parent)
 
     def _assert_qc(self):
-        sr = spikeglx.Reader(self.file_path)
-        saturated = np.load(
-            self.file_path.parent.joinpath("_iblqc_ephysSaturation.samples.npy")
+        df_saturated = pd.read_parquet(
+            self.file_path.parent.joinpath("_iblqc_ephysSaturation.samples.pqt")
         )
-        self.assertEqual(sr.ns, saturated.size)
+        self.assertTrue(df_saturated.shape[1] == 2)
+
         self.assertTrue(
             self.file_path.parent.joinpath("_iblqc_ephysTimeRmsAP.rms.npy").exists()
         )

tests/unit/test_spikeglx.py

@@ -2,6 +2,7 @@ from pathlib import Path
 import shutil
 import tempfile
 import unittest
+import uuid
 
 import numpy as np
 from iblutil.io import hashfile
@@ -671,9 +672,29 @@ class TestsBasicReader(unittest.TestCase):
     Tests the basic usage where there is a flat binary and no metadata associated
     """
 
-    def test_get_companion_file(self):
-        import uuid
+    def test_integration_companion_files_cbin(self):
+        with tempfile.TemporaryDirectory() as td:
+            bin_file_orig = Path(td) / "toto.ap.bin"
+            meta_file = Path(td) / f"toto.ap.{str(uuid.uuid4())}.meta"
+            ch_file = Path(td) / f"toto.ap.{str(uuid.uuid4())}.ch"
+            spikeglx._mock_spikeglx_file(
+                bin_file_orig,
+                meta_file=Path(TEST_PATH).joinpath("sample3B_g0_t0.imec1.ap.meta"),
+                ns=90_000,
+                nc=385,
+            )
+            sr = spikeglx.Reader(bin_file_orig)
+            sr.compress_file(keep_original=False)
+            cbin_file = Path(td) / f"toto.ap.{str(uuid.uuid4())}.cbin"
+            shutil.move(bin_file_orig.with_suffix(".cbin"), cbin_file)
+            shutil.move(bin_file_orig.with_suffix(".ch"), ch_file)
+            shutil.move(bin_file_orig.with_suffix(".meta"), meta_file)
+            sr = spikeglx.Reader(cbin_file)
+            self.assertEqual(sr.file_bin, cbin_file)
+            self.assertEqual(sr.file_meta_data, meta_file)
+            self.assertEqual(sr.ch_file, ch_file)
 
+    def test_get_companion_file(self):
         with tempfile.TemporaryDirectory() as td:
             sglx_file = Path(td) / f"sample3A_g0_t0.imec.ap.{str(uuid.uuid4())}.bin"
             meta_file = Path(td) / f"sample3A_g0_t0.imec.ap.{str(uuid.uuid4())}.meta"

tests/unit/test_utils.py

@@ -69,8 +69,8 @@ class TestSyncTimestamps(unittest.TestCase):
 
 class TestParabolicMax(unittest.TestCase):
     # expected values
-    maxi = np.array([np.nan, 0, 3.04166667, 3.04166667, 5, 5])
-    ipeak = np.array([np.nan, 0, 5.166667, 2.166667, 0, 7])
+    maxi = np.array([0.0, 0.0, 3.04166667, 3.04166667, 5, 5])
+    ipeak = np.array([0.0, 0.0, 5.166667, 2.166667, 0, 7])
     # input
     x = np.array(
         [

tests/unit/test_voltage.py

@@ -131,6 +131,24 @@ class TestSaturation(unittest.TestCase):
         self.assertGreater(np.sum(saturated), 5)
         self.assertGreater(np.sum(mute == 0), np.sum(saturated))
 
+    def test_saturation_intervals_output(self):
+        saturation = np.zeros(50_000, dtype=bool)
+        # we test empty files, make sure we can read/write from empty parquet
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create a file path within the temporary directory
+            temp_file = Path(temp_dir).joinpath("saturation.pqt")
+            df_nothing = ibldsp.voltage.saturation_samples_to_intervals(
+                saturation, output_file=Path(temp_dir).joinpath("saturation.pqt")
+            )
+            df_nothing2 = pd.read_parquet(temp_file)
+        self.assertEqual(df_nothing.shape[0], 0)
+        self.assertEqual(df_nothing2.shape[0], 0)
+        # for the case with saturation intervals, we simply test the number of rows correspond to the events
+        saturation[3441:3509] = True
+        saturation[45852:45865] = True
+        df_sat = ibldsp.voltage.saturation_samples_to_intervals(saturation)
+        self.assertEqual(81, np.sum(df_sat["stop_sample"] - df_sat["start_sample"]))
+
 
 class TestCadzow(unittest.TestCase):
     def test_trajectory_matrixes(self):