ibl-neuropixel 1.8.0__tar.gz → 1.9.0__tar.gz

{ibl_neuropixel-1.8.0/src/ibl_neuropixel.egg-info → ibl_neuropixel-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibl-neuropixel
-Version: 1.8.0
+Version: 1.9.0
 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
@@ -71,22 +71,4 @@ The following describes the methods implemented in this repository.
 https://doi.org/10.6084/m9.figshare.19705522
 
 ## Contribution
-Contribution checklist:
-- run tests
-- ruff format
-- PR to main
-
-
-Pypi Release checklist:
-- Edit the version number in `setup.py`
-- add release notes in `release_notes.md`
-
-
-```shell
-ruff format
-tag=X.Y.Z
-git tag -a $tag 
-git push origin $tag
-```
-
-Create new release with tag X.Y.Z (will automatically publish to PyPI)
+Please see our [contribution guidelines](CONTRIBUTING.md) for details on how to contribute to this project.

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0}/README.md

@@ -39,22 +39,4 @@ The following describes the methods implemented in this repository.
 https://doi.org/10.6084/m9.figshare.19705522
 
 ## Contribution
-Contribution checklist:
-- run tests
-- ruff format
-- PR to main
-
-
-Pypi Release checklist:
-- Edit the version number in `setup.py`
-- add release notes in `release_notes.md`
-
-
-```shell
-ruff format
-tag=X.Y.Z
-git tag -a $tag 
-git push origin $tag
-```
-
-Create new release with tag X.Y.Z (will automatically publish to PyPI)
+Please see our [contribution guidelines](CONTRIBUTING.md) for details on how to contribute to this project.

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt") as f:
 
 setuptools.setup(
     name="ibl-neuropixel",
-    version="1.8.0",
+    version="1.9.0",
     author="The International Brain Laboratory",
     description="Collection of tools for Neuropixel 1.0 and 2.0 probes data",
     long_description=long_description,

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0/src/ibl_neuropixel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibl-neuropixel
-Version: 1.8.0
+Version: 1.9.0
 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
@@ -71,22 +71,4 @@ The following describes the methods implemented in this repository.
 https://doi.org/10.6084/m9.figshare.19705522
 
 ## Contribution
-Contribution checklist:
-- run tests
-- ruff format
-- PR to main
-
-
-Pypi Release checklist:
-- Edit the version number in `setup.py`
-- add release notes in `release_notes.md`
-
-
-```shell
-ruff format
-tag=X.Y.Z
-git tag -a $tag 
-git push origin $tag
-```
-
-Create new release with tag X.Y.Z (will automatically publish to PyPI)
+Please see our [contribution guidelines](CONTRIBUTING.md) for details on how to contribute to this project.

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0}/src/ibl_neuropixel.egg-info/SOURCES.txt

@@ -59,7 +59,9 @@ src/tests/integration/csd_experiments.py
 src/tests/integration/test_destripe.py
 src/tests/unit/__init__.py
 src/tests/unit/test_ephys_np2.py
-src/tests/unit/test_ibldsp.py
 src/tests/unit/test_neuropixel.py
+src/tests/unit/test_plots.py
 src/tests/unit/test_spikeglx.py
+src/tests/unit/test_utils.py
+src/tests/unit/test_voltage.py
 src/tests/unit/test_waveforms.py

ibl_neuropixel-1.9.0/src/ibldsp/plots.py

@@ -0,0 +1,135 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+AP_RANGE_UV = 75
+LF_RANGE_UV = 250
+
+
+def show_channels_labels(
+    raw,
+    fs,
+    channel_labels,
+    xfeats,
+    similarity_threshold=(-0.5, 1),
+    psd_hf_threshold=0.02,
+):
+    """
+    Shows the features side by side a snippet of raw data
+    :param sr:
+    :return:
+    """
+    nc, ns = raw.shape
+    raw = raw - np.mean(raw, axis=-1)[:, np.newaxis]  # removes DC offset
+    ns_plot = np.minimum(ns, 3000)
+    fig, ax = plt.subplots(
+        1, 5, figsize=(18, 6), gridspec_kw={"width_ratios": [1, 1, 1, 8, 0.2]}
+    )
+    ax[0].plot(xfeats["xcor_hf"], np.arange(nc))
+    ax[0].plot(  # plot channel below the similarity threshold as dead in black
+        xfeats["xcor_hf"][(iko := channel_labels == 1)], np.arange(nc)[iko], "k*"
+    )
+    ax[0].plot(  # plot the values above the similarity threshold as noisy in red
+        xfeats["xcor_hf"][
+            (iko := np.where(xfeats["xcor_hf"] > similarity_threshold[1]))
+        ],
+        np.arange(nc)[iko],
+        "r*",
+    )
+    ax[0].plot(similarity_threshold[0] * np.ones(2), [0, nc], "k--")
+    ax[0].plot(similarity_threshold[1] * np.ones(2), [0, nc], "r--")
+    ax[0].set(
+        ylabel="channel #",
+        xlabel="high coherence",
+        ylim=[0, nc],
+        title="a) dead channel",
+    )
+    ax[1].plot(xfeats["psd_hf"], np.arange(nc))
+    ax[1].plot(
+        xfeats["psd_hf"][(iko := xfeats["psd_hf"] > psd_hf_threshold)],
+        np.arange(nc)[iko],
+        "r*",
+    )
+    ax[1].plot(psd_hf_threshold * np.array([1, 1]), [0, nc], "r--")
+    ax[1].set(yticklabels=[], xlabel="PSD", ylim=[0, nc], title="b) noisy channel")
+    ax[1].sharey(ax[0])
+    ax[2].plot(xfeats["xcor_lf"], np.arange(nc))
+    ax[2].plot(
+        xfeats["xcor_lf"][(iko := channel_labels == 3)], np.arange(nc)[iko], "y*"
+    )
+    ax[2].plot([-0.75, -0.75], [0, nc], "y--")
+    ax[2].set(yticklabels=[], xlabel="LF coherence", ylim=[0, nc], title="c) outside")
+    ax[2].sharey(ax[0])
+    voltageshow(raw[:, :ns_plot], fs, ax=ax[3], cax=ax[4])
+    ax[3].sharey(ax[0])
+    fig.tight_layout()
+    return fig, ax
+
+
+def voltageshow(
+    raw,
+    fs,
+    cmap="PuOr",
+    ax=None,
+    cax=None,
+    cbar_label="Voltage (uV)",
+    scaling=1e6,
+    vrange=None,
+    **axis_kwargs,
+):
+    """
+    Visualizes electrophysiological voltage data as a heatmap.
+
+    This function displays raw voltage data as a color-coded image with appropriate
+    scaling based on the sampling frequency. It automatically selects voltage range
+    based on whether the data is low-frequency (LF) or action potential (AP) data.
+
+    Parameters
+    ----------
+    raw : numpy.ndarray
+        Raw voltage data array with shape (channels, samples), in Volts
+    fs : float
+        Sampling frequency in Hz, used to determine time axis scaling and voltage range.
+    cmap : str, optional
+        Matplotlib colormap name for the heatmap. Default is 'PuOr'.
+    ax : matplotlib.axes.Axes, optional
+        Axes object to plot on. If None, a new figure and axes are created.
+    cax : matplotlib.axes.Axes, optional
+        Axes object for the colorbar. If None and ax is None, a new colorbar axes is created.
+    cbar_label : str, optional
+        Label for the colorbar. Default is 'Voltage (uV)'.
+    vrange: float, optional
+        Voltage range for the colorbar. Defaults to +/- 75 uV for AP and +/- 250 uV for LF.
+    scaling: float, optional
+        Unit transform: default is 1e6: we expect Volts but plot uV.
+    **axis_kwargs: optional
+        Additional keyword arguments for the axis properties, fed to the ax.set() method.
+    Returns
+    -------
+    matplotlib.image.AxesImage
+        The image object created by imshow, which can be used for further customization.
+    """
+    if ax is None:
+        fig, axs = plt.subplots(1, 2, gridspec_kw={"width_ratios": [1, 0.05]})
+        ax, cax = axs
+    nc, ns = raw.shape
+    default_vrange = LF_RANGE_UV if fs < 2600 else AP_RANGE_UV
+    vrange = vrange if vrange is not None else default_vrange
+    im = ax.imshow(
+        raw * scaling,
+        origin="lower",
+        cmap=cmap,
+        aspect="auto",
+        vmin=-vrange,
+        vmax=vrange,
+        extent=[0, ns / fs, 0, nc],
+    )
+    # set the axis properties: we use defaults values that can be overridden by user-provided ones
+    axis_kwargs = (
+        dict(ylim=[0, nc], xlabel="Time (s)", ylabel="Depth (μm)") | axis_kwargs
+    )
+    ax.set(**axis_kwargs)
+    ax.grid(False)
+    if cax is not None:
+        plt.colorbar(im, cax=cax, shrink=0.8).ax.set(ylabel=cbar_label)
+
+    return im

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0}/src/ibldsp/utils.py

@@ -268,12 +268,64 @@ def make_channel_index(geom, radius=200.0, pad_val=None):
 
 class WindowGenerator(object):
     """
-    `wg = WindowGenerator(ns, nswin, overlap)`
+    A utility class for generating sliding windows for signal processing applications.
 
-    Provide sliding windows indices generator for signal processing applications.
-    For straightforward spectrogram / periodogram implementation, prefer scipy methods !
+    WindowGenerator provides various methods to iterate through windows of a signal
+    with configurable window size and overlap. It's particularly useful for operations
+    like spectrograms, filtering, or any processing that requires windowed analysis.
 
-    Example of implementations in test_dsp.py.
+    Parameters
+    ----------
+    ns : int
+        Total number of samples in the signal to be windowed.
+    nswin : int
+        Number of samples in each window.
+    overlap : int
+        Number of samples that overlap between consecutive windows.
+
+    Attributes
+    ----------
+    ns : int
+        Total number of samples in the signal.
+    nswin : int
+        Number of samples in each window.
+    overlap : int
+        Number of samples that overlap between consecutive windows.
+    nwin : int
+        Total number of windows.
+    iw : int or None
+        Current window index during iteration.
+
+    Notes
+    -----
+    For straightforward spectrogram or periodogram implementation,
+    scipy methods are recommended over this class.
+
+    Examples
+    --------
+    # straight windowing without overlap
+    >>> wg = WindowGenerator(ns=1000, nwin=111)
+    >>> signal = np.random.randn(1000)
+    >>> for window_slice in wg.slice:
+    ...     window_data = signal[window_slice]
+    ...     # Process window_data
+
+    # windowing with overlap (ie. buffers for apodization)
+    >>> for win_slice, valid_slice, win_valid_slice in wg.slices_valid:
+    ...     window = signal[win_slice]
+    ...     # Process window
+    ...     processed = some_function_with_edge_effect(window)
+    ...     # Only use the valid portion for reconstruction
+    ...     recons[valid_slice] = processed[win_valid_slice]
+
+    # splicing add a fade-in / fade-out in the overlap so that reconstruction has unit amplitude
+    >>> recons = np.zeros_like(signal)
+    >>> for win_slice, amplitude in wg.splice:
+    ...     window = signal[win_slice]
+    ...     # Process window
+    ...     processed = some_function(window)
+    ...     # The processed windows is weighted with the amplitude and added to the reconstructed signal
+    ...     recons[win_slice] = recons[win_slice] + processed * amplitude
     """
 
     def __init__(self, ns, nswin, overlap):
@@ -289,14 +341,35 @@ class WindowGenerator(object):
         self.iw = None
 
     @property
-    def firstlast_splicing(self):
+    def splice(self):
+        """
+        Generator that yields slices and amplitude arrays for windowed signal processing with splicing.
+
+        This property provides a convenient way to iterate through all windows with their
+        corresponding amplitude arrays for proper signal reconstruction. The amplitude arrays
+        contain tapering values (from a Hann window) at the overlapping regions to ensure
+        unit amplitude of all samples of the original signal
+
+        Yields
+        ------
+        tuple
+            A tuple containing:
+            - slice: A Python slice object representing the current window
+            - amp: A numpy array containing amplitude values for proper splicing/tapering
+              at overlap regions
+
+        Notes
+        -----
+        This is particularly useful for overlap-add methods where windows need to be
+        properly weighted before being combined in the reconstruction process.
         """
-        Generator that yields the indices as well as an amplitude function that can be used
-        to splice the windows together.
-        In the overlap, the amplitude function gradually transitions the amplitude from one window
-        to the next. The amplitudes always sum to one (ie. windows are symmetrical)
+        for first, last, amp in self.firstlast_splicing:
+            yield slice(first, last), amp
 
-        :return: tuple of (first_index, last_index, amplitude_vector]
+    @property
+    def firstlast_splicing(self):
+        """
+        cf. self.splice
         """
         w = scipy.signal.windows.hann((self.overlap + 1) * 2 + 1, sym=True)[
             1 : self.overlap + 1
@@ -323,7 +396,7 @@ class WindowGenerator(object):
             yield (first, last, first_valid, last_valid)
 
     @property
-    def firstlast(self, return_valid=False):
+    def firstlast(self):
         """
         Generator that yields first and last index of windows
 
@@ -343,13 +416,51 @@ class WindowGenerator(object):
     @property
     def slice(self):
         """
-        Generator that yields slices of windows
-
-        :return: a slice of the window
+        Generator that yields slice objects for each window in the signal.
+
+        This property provides a convenient way to iterate through all windows
+        defined by the WindowGenerator parameters. Each yielded slice can be
+        used directly to index into the original signal array.
+
+        Yields
+        ------
+        slice
+            A Python slice object representing the current window, defined by
+            its first and last indices. The slice can be used to extract the
+            corresponding window from the original signal.
         """
         for first, last in self.firstlast:
             yield slice(first, last)
 
+    @property
+    def slices_valid(self):
+        """
+        Generator that yields slices for windowed signal processing with valid regions.
+
+        This method generates tuples of slice objects that can be used to extract windows
+        from a signal and identify the valid (non-overlapping) portions within each window.
+        It's particularly useful for reconstruction operations where overlapping regions
+        need special handling.
+
+        Yields
+        ------
+        tuple
+            A tuple containing three slice objects:
+            - slice(first, last): The full window slice
+            - slice(first_valid, last_valid): The valid portion of the signal in absolute indices
+            - slice_window_valid: The valid portion relative to the window (for use within the window)
+
+        Notes
+        -----
+        This generator relies on the firstlast_valid property which provides the
+        indices for both the full windows and their valid regions.
+        """
+        for first, last, first_valid, last_valid in self.firstlast_valid:
+            slice_window_valid = slice(
+                first_valid - first, None if (lv := -(last - last_valid)) == 0 else lv
+            )
+            yield slice(first, last), slice(first_valid, last_valid), slice_window_valid
+
     def slice_array(self, sig, axis=-1):
         """
         Provided an array or sliceable object, generator that yields

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0}/src/ibldsp/voltage.py

@@ -3,6 +3,8 @@ Module to work with raw voltage traces. Spike sorting pre-processing functions.
 """
 
 import inspect
+import joblib
+import tqdm
 from pathlib import Path
 
 import numpy as np
@@ -217,6 +219,7 @@ def kfilt(
         xf, gain = agc(x, wl=lagc, si=1.0, gpu=gpu)
     if ntr_pad > 0:
         # pad the array with a mirrored version of itself and apply a cosine taper
+        ntr_pad = np.min([ntr_pad, xf.shape[0]])
         xf = gp.r_[gp.flipud(xf[:ntr_pad]), xf, gp.flipud(xf[-ntr_pad:])]
     if ntr_tap > 0:
         taper = fourier.fcn_cosine([0, ntr_tap], gpu=gpu)(gp.arange(nxp))  # taper up
@@ -266,6 +269,120 @@ def saturation(
     return saturation, mute
 
 
+def saturation_samples_to_intervals(
+    _saturation: np.ndarray, output_file: Path = None
+) -> pd.DataFrame:
+    """
+    Convert a flat npy file to a table with saturation intervals.
+    :param _saturation: np.ndarray: Boolean array with saturation samples set as True
+    :return:
+    """
+    assert not _saturation[0]
+    ind, pol = ibldsp.utils.fronts(_saturation.astype(np.int8))
+    # if the last sample is positive, make sure the interval is closed by providing an even number of events
+    if len(pol) > 0 and pol[-1] == 1:
+        pol = np.r_[pol, -1]
+        ind = np.r_[ind, _saturation.shape[0] - 1]
+    df_saturation = pd.DataFrame(
+        np.c_[ind[::2], ind[1::2]], columns=["start_sample", "stop_sample"]
+    )
+    if output_file is not None:
+        df_saturation.to_parquet(output_file)
+    return df_saturation
+
+
+def saturation_cbin(
+    bin_file_path: Path,
+    file_saturation: Path = None,
+    max_voltage=None,
+    n_jobs=4,
+    v_per_sec=1e-8,
+    proportion=0.2,
+    mute_window_samples=7,
+) -> Path:
+    """
+    Detect saturation in a compressed binary (cbin) electrophysiology file and save the results.
+
+    This function processes a SpikeGLX binary file in chunks to identify saturated samples
+    and saves the results as a memory-mapped boolean array. Processing is parallelized
+    for improved performance.
+
+    Parameters
+    ----------
+    bin_file_path : Path | spikeglx.Reader
+        Path to the SpikeGLX binary file to be processed or spikeglx.Reader object
+    file_saturation : Path, optional
+        Path where the saturation data will be saved. If None, defaults to
+        "_iblqc_ephysSaturation.samples.npy" in the same directory as the input file
+    max_voltage : np.float, optional
+        one-sided maximum voltage range (V), if not provided will use the spikeglx metadata
+    n_jobs : int, optional
+        Number of parallel jobs to use for processing, defaults to 4
+    v_per_sec : float, optional
+        Maximum derivative of the voltage in V/s (or units/s), defaults to 1e-8
+    proportion : float, optional
+        Threshold proportion (0-1) of channels that must be above threshold to consider
+        a sample as saturated, defaults to 0.2
+    mute_window_samples : int, optional
+        Number of samples for the cosine taper applied to the saturation, defaults to 7
+
+    Returns
+    -------
+    Path
+        Path to the file where the saturation data was saved
+    """
+    if isinstance(bin_file_path, spikeglx.Reader):
+        sr = bin_file_path
+        bin_file_path = sr.file_bin
+    else:
+        sr = spikeglx.Reader(bin_file_path)
+    file_saturation = (
+        file_saturation
+        if file_saturation is not None
+        else bin_file_path.parent.joinpath("_iblqc_ephysSaturation.samples.npy")
+    )
+    max_voltage = max_voltage if max_voltage is not None else sr.range_volts[:-1]
+    # Create a memory-mapped array
+    _saturation = np.lib.format.open_memmap(
+        file_saturation, dtype=bool, mode="w+", shape=(sr.ns,)
+    )
+    _saturation[:] = False  # Initialize all values to False
+    _saturation.flush()  # Make sure to flush to disk
+
+    wg = ibldsp.utils.WindowGenerator(ns=sr.ns, nswin=2**17, overlap=16)
+
+    # we can parallelize this as there is no conflict on output
+    def _saturation_slice(slice_win, slice_valid, slice_relative_valid):
+        sr = spikeglx.Reader(bin_file_path)
+        data = sr[slice_win, : sr.nc - sr.nsync].T
+        satwin, _ = ibldsp.voltage.saturation(
+            data,
+            max_voltage=max_voltage,
+            fs=sr.fs,
+            v_per_sec=v_per_sec,
+            proportion=proportion,
+            mute_window_samples=mute_window_samples,
+        )
+        _saturation[slice_valid] = satwin[slice_relative_valid]
+        _saturation.flush()
+        # getting the list of jobs as a generator allows running tqdm to monitor progress
+
+    jobs = [
+        joblib.delayed(_saturation_slice)(slw, slv, slrv)
+        for (slw, slv, slrv) in wg.slices_valid
+    ]
+    list(
+        tqdm.tqdm(
+            joblib.Parallel(return_as="generator", n_jobs=n_jobs)(jobs), total=wg.nwin
+        )
+    )
+
+    _ = saturation_samples_to_intervals(
+        _saturation, output_file=file_saturation.with_suffix(".pqt")
+    )
+    return file_saturation.with_suffix(".pqt")
+
+
 def interpolate_bad_channels(
     data, channel_labels=None, x=None, y=None, p=1.3, kriging_distance_um=20, gpu=False
 ):
@@ -456,8 +573,9 @@ def decompress_destripe_cbin(
     :param nbatch: (optional) batch size
     :param nprocesses: (optional) number of parallel processes to run, defaults to number or processes detected with joblib
      interp 3:outside of brain and discard
-    :param reject_channels: (True) detects noisy or bad channels and interpolate them. Channels outside of the brain are left
-     untouched
+    :param reject_channels: (True) True | False | np.array()
+      If True, detects noisy or bad channels and interpolate them, zero out the channels outside the brain.
+      If the labels are already computed, they can be provided as a numpy array.
     :param k_kwargs: (None) arguments for the kfilter function
     :param reader_kwargs: (None) optional arguments for the spikeglx Reader instance
     :param k_filter: (True) True | False | None | custom function.
@@ -475,8 +593,11 @@ def decompress_destripe_cbin(
     # handles input parameters
     reader_kwargs = {} if reader_kwargs is None else reader_kwargs
     sr = spikeglx.Reader(sr_file, open=True, **reader_kwargs)
-    if reject_channels:  # get bad channels if option is on
+    if reject_channels is True:  # get bad channels if option is on
         channel_labels = detect_bad_channels_cbin(sr)
+    elif isinstance(reject_channels, np.ndarray):
+        channel_labels = reject_channels
+        reject_channels = True
     assert isinstance(sr_file, str) or isinstance(sr_file, Path)
     butter_kwargs, k_kwargs, spatial_fcn = _get_destripe_parameters(
         sr.fs, butter_kwargs, k_kwargs, k_filter
@@ -502,7 +623,6 @@ def decompress_destripe_cbin(
     DEPHAS = np.exp(
         1j * np.angle(fft_object(dephas)) * h["sample_shift"][:, np.newaxis]
     )
-
     # if we want to compute the rms ap across the session as well as the saturation
     if compute_rms:
         # creates a saturation memmap, this is a nsamples vector of booleans
@@ -652,6 +772,9 @@ def decompress_destripe_cbin(
         saturation_data = np.load(file_saturation)
         assert rms_data.shape[0] == time_data.shape[0] * ncv
         rms_data = rms_data.reshape(time_data.shape[0], ncv)
+        # Save the rms data using the original channel index
+        unsort = np.argsort(sr.raw_channel_order)[: -sr.nsync]
+        rms_data = rms_data[:, unsort]
         output_qc_path = (
             output_file.parent if output_qc_path is None else output_qc_path
         )
@@ -772,7 +895,23 @@ def detect_bad_channels(
         )
     )[0]
     # the channels outside of the brains are the contiguous channels below the threshold on the trend coherency
-    ioutside = np.where(xfeats["xcor_lf"] < -0.75)[0]  # fixme: hardcoded threshold
+
+    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([])
+
     if ioutside.size > 0 and ioutside[-1] == (nc - 1):
         a = np.cumsum(np.r_[0, np.diff(ioutside) - 1])
         ioutside = ioutside[a == np.max(a)]
@@ -915,16 +1054,39 @@ def stack(data, word, fcn_agg=np.nanmean, header=None):
 
 def current_source_density(lfp, h, n=2, method="diff", sigma=1 / 3):
     """
-    Compute the current source density (CSD) of a given LFP signal recorded on neuropixel 1 or 2
-    :param data: LFP signal (n_channels, n_samples)
-    :param h: trace header dictionary
-    :param n: the n derivative
-    :param method: diff (straight double difference) or kernel CSD (needs the KCSD python package)
-    :param sigma: conductivity, defaults to 1/3 S.m-1
-    :return:
+    Compute the current source density (CSD) of a given LFP signal recorded on Neuropixel probes.
+
+    The CSD estimates the location of current sources and sinks in neural tissue based on
+    the spatial distribution of local field potentials (LFPs). This implementation supports
+    both the standard double-derivative method and kernel CSD method.
+
+    The CSD is computed for each column of the Neuropixel probe layout separately.
+
+    Parameters
+    ----------
+    lfp : numpy.ndarray
+        LFP signal array with shape (n_channels, n_samples)
+    h : dict
+        Trace header dictionary containing probe geometry information with keys:
+        'x', 'y' for electrode coordinates, 'col' for column indices, and 'row' for row indices
+    n : int, optional
+        Order of the derivative for the 'diff' method, defaults to 2
+    method : str, optional
+        Method to compute CSD:
+        - 'diff': standard finite difference method (default)
+        - 'kcsd': kernel CSD method (requires the KCSD Python package)
+    sigma : float, optional
+        Tissue conductivity in Siemens per meter, defaults to 1/3 S.m-1
+
+    Returns
+    -------
+    numpy.ndarray
+        Current source density with the same shape as the input LFP array.
+        Positive values indicate current sources, negative values indicate sinks.
+        Units are in A.m-3 (amperes per cubic meter).
     """
     csd = np.zeros(lfp.shape, dtype=np.float64) * np.nan
-    xy = h["x"] + 1j * h["y"]
+    xy = (h["x"] + 1j * h["y"]) / 1e6
     for col in np.unique(h["col"]):
         ind = np.where(h["col"] == col)[0]
         isort = np.argsort(h["row"][ind])
@@ -971,7 +1133,6 @@ def _svd_denoise(datr, rank):
 
 def svd_denoise_npx(datr, rank=None, collection=None):
     """
-
     :param datr: [nc, ns]
     :param rank:
     :param collection:

{ibl_neuropixel-1.8.0 → ibl_neuropixel-1.9.0}/src/ibldsp/waveform_extraction.py

@@ -280,6 +280,7 @@ def extract_wfs_cbin(
     chunksize_samples=int(30_000),
     reader_kwargs=None,
     n_jobs=None,
+    wfs_dtype=np.float32,
     preprocess_steps=None,
     seed=None,
     scratch_dir=None,