disdrodb 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

disdrodb/utils/cli.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -105,7 +103,7 @@ def click_data_archive_dir_option(function: object):
         type=str,
         show_default=True,
         default=None,
-        help="DISDRODB base directory",
+        help="DISDRODB Data Archive Directory. Format: <...>/DISDRODB",
     )(function)
     return function
 
@@ -123,7 +121,7 @@ def click_metadata_archive_dir_option(function: object):
         type=str,
         show_default=True,
         default=None,
-        help="DISDRODB Metadata Archive Directory",
+        help="DISDRODB Metadata Archive Directory. Format: <...>/DISDRODB-METADATA/DISDRODB",
     )(function)
     return function
 
@@ -233,14 +231,14 @@ def click_l0_archive_options(function: object):
         type=bool,
         show_default=True,
         default=False,
-        help="If true, remove all source L0B files once L0B concatenation is terminated.",
+        help="If True, remove L0B files after L0C.",
     )(function)
     function = click.option(
         "--remove_l0a",
         type=bool,
         show_default=True,
         default=False,
-        help="If true, remove the L0A files once the L0B processing is terminated.",
+        help="If True, remove L0A files after L0B.",
     )(function)
     function = click.option(
         "-l0c",
@@ -248,7 +246,7 @@ def click_l0_archive_options(function: object):
         type=bool,
         show_default=True,
         default=True,
-        help="Perform L0C processing.",
+        help="Run L0C processing",
     )(function)
     function = click.option(
         "-l0b",
@@ -256,7 +254,7 @@ def click_l0_archive_options(function: object):
         type=bool,
         show_default=True,
         default=True,
-        help="Perform L0B processing.",
+        help="Run L0B processing",
     )(function)
     function = click.option(
         "-l0a",
@@ -264,6 +262,6 @@ def click_l0_archive_options(function: object):
         type=bool,
         show_default=True,
         default=True,
-        help="Perform L0A processing.",
+        help="Run L0A processing",
     )(function)
     return function

disdrodb/utils/compression.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -25,7 +23,6 @@ import shutil
 import subprocess
 import tempfile
 import zipfile
-from typing import Optional
 
 from disdrodb.api.checks import check_data_archive_dir
 from disdrodb.api.path import define_station_dir
@@ -190,13 +187,13 @@ def compress_station_files(
     # Get list of files inside the station directory (in all nested directories)
     filepaths = list_files(station_dir, recursive=True)
     for filepath in filepaths:
-        _ = _compress_file(filepath, method, skip=skip)
+        _ = compress_file(filepath, method, skip=skip)
 
     print(f"All files of {data_source} {campaign_name} {station_name} have been compressed.")
     print("Please now remember to update the glob_pattern of the reader ¨!")
 
 
-def _compress_file(filepath: str, method: str, skip: bool) -> str:
+def compress_file(filepath: str, method: str, skip: bool) -> str:
     """Compress a file and delete the original.
 
     If the file is already compressed, it is not compressed again.
@@ -230,9 +227,9 @@ def _compress_file(filepath: str, method: str, skip: bool) -> str:
     archive_name = os.path.basename(filepath) + extension
     compressed_filepath = os.path.join(os.path.dirname(filepath), archive_name)
     compress_file_function = {
-        "zip": _compress_file_zip,
-        "gzip": _compress_file_gzip,
-        "bzip2": _compress_file_bzip2,
+        "zip": compress_file_zip,
+        "gzip": compress_file_gzip,
+        "bzip2": compress_file_bzip2,
     }[method]
 
     compress_file_function(filepath, compressed_filepath)
@@ -241,7 +238,7 @@ def _compress_file(filepath: str, method: str, skip: bool) -> str:
     return compressed_filepath
 
 
-def _check_file_compression(filepath: str) -> Optional[str]:
+def _check_file_compression(filepath: str) -> str | None:
     """Check the method used to compress a raw text file.
 
     From https://stackoverflow.com/questions/13044562/python-mechanism-to-identify-compressed-file-type-and-uncompress
@@ -271,7 +268,7 @@ def _check_file_compression(filepath: str) -> Optional[str]:
     return None
 
 
-def _compress_file_zip(filepath: str, compressed_filepath: str) -> None:
+def compress_file_zip(filepath: str, compressed_filepath: str) -> None:
     """Compress a single file into a zip archive.
 
     Parameters
@@ -287,7 +284,7 @@ def _compress_file_zip(filepath: str, compressed_filepath: str) -> None:
         zipf.write(filepath, os.path.basename(filepath))
 
 
-def _compress_file_gzip(filepath: str, compressed_filepath: str) -> None:
+def compress_file_gzip(filepath: str, compressed_filepath: str) -> None:
     """Compress a single file into a gzip archive.
 
     Parameters
@@ -303,7 +300,7 @@ def _compress_file_gzip(filepath: str, compressed_filepath: str) -> None:
         f_out.writelines(f_in)
 
 
-def _compress_file_bzip2(filepath: str, compressed_filepath: str) -> None:
+def compress_file_bzip2(filepath: str, compressed_filepath: str) -> None:
     """Compress a single file into a bzip2 archive.
 
     Parameters

disdrodb/utils/coords.py

@@ -0,0 +1,45 @@
+# -----------------------------------------------------------------------------.
+# Copyright (c) 2021-2026 DISDRODB developers
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# -----------------------------------------------------------------------------.
+"""DISDRODB coordinates utilities."""
+
+
+def add_dataset_crs_coords(xr_obj):
+    """Add a CF-compliant CRS (WGS84) to an xarray.Dataset."""
+    import xarray as xr
+
+    crs_wkt = (
+        'GEOGCRS["WGS 84",'
+        'DATUM["World Geodetic System 1984",'
+        'ELLIPSOID["WGS 84",6378137,298.257223563, LENGTHUNIT["metre",1]]],'
+        'PRIMEM["Greenwich",0, ANGLEUNIT["degree",0.0174532925199433]],'
+        "CS[ellipsoidal,2],"
+        'AXIS["geodetic latitude",north, ANGLEUNIT["degree",0.0174532925199433]],'
+        'AXIS["geodetic longitude",east, ANGLEUNIT["degree",0.0174532925199433]],'
+        'UNIT["degree",0.0174532925199433]'
+    )
+    da_crs = xr.DataArray(
+        0,
+        attrs={
+            "grid_mapping_name": "latitude_longitude",
+            "crs_wkt": crs_wkt,
+            "epsg_code": "EPSG:4326",
+            "semi_major_axis": 6378137.0,
+            "inverse_flattening": 298.257223563,
+            "longitude_of_prime_meridian": 0.0,
+        },
+    )
+    return xr_obj.assign_coords({"crs": da_crs})

disdrodb/utils/dask.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Utilities for Dask Distributed Computations."""
+
 import logging
 import os
 
@@ -30,9 +29,9 @@ def check_parallel_validity(parallel):
     scheduler = dask.config.get("scheduler", None)
     if scheduler is None:
         return parallel
-    if scheduler in ["synchronous", "threads"]:
+    if scheduler in ["synchronous", "threads", "single-threaded"]:
         return False
-    if scheduler == "distributed":
+    if scheduler in ["distributed", "dask.distributed"]:
         from dask.distributed import default_client
 
         client = default_client()
@@ -62,6 +61,8 @@ def initialize_dask_cluster(minimum_memory=None):
     import psutil
 
     # Silence dask warnings
+    # dask.config.set({'distributed.worker.multiprocessing-method': 'forkserver'})
+    # dask.config.set({"distributed.worker.multiprocessing-method": "spawn"})
     # dask.config.set({"logging.distributed": "error"})
     # Import dask.distributed after setting the config
     from dask.distributed import Client, LocalCluster
@@ -71,6 +72,7 @@ def initialize_dask_cluster(minimum_memory=None):
     os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
 
     # Retrieve the number of processes to run
+    # --> If DASK_NUM_WORKERS is not set, use all CPUs minus 2
     available_workers = os.cpu_count() - 2  # if not set, all CPUs minus 2
     num_workers = dask.config.get("num_workers", available_workers)
 

disdrodb/utils/dataframe.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Dataframe utilities."""
+
 import numpy as np
 import pandas as pd
 
@@ -209,7 +208,7 @@ def compute_1d_histogram(df, column, variables=None, bins=10, labels=None, prefi
 
     # Reset index and add coordinates/labels
     df_stats = df_stats.reset_index()
-    df_stats[f"{column}"] = pd.Categorical(df_stats[f"{column}_binned"].map(dict(zip(intervals, coords, strict=False))))
+    df_stats[f"{column}"] = pd.Categorical(df_stats[f"{column}_binned"].map(dict(zip(intervals, coords, strict=True))))
     df_stats = df_stats.drop(columns=f"{column}_binned")
 
     return df_stats
@@ -375,8 +374,8 @@ def compute_2d_histogram(
 
     # Reset index and set new coordinates
     df_stats = df_stats.reset_index()
-    df_stats[f"{x}"] = pd.Categorical(df_stats[f"{x}_binned"].map(dict(zip(x_intervals, x_coords, strict=False))))
-    df_stats[f"{y}"] = pd.Categorical(df_stats[f"{y}_binned"].map(dict(zip(y_intervals, y_coords, strict=False))))
+    df_stats[f"{x}"] = pd.Categorical(df_stats[f"{x}_binned"].map(dict(zip(x_intervals, x_coords, strict=True))))
+    df_stats[f"{y}"] = pd.Categorical(df_stats[f"{y}_binned"].map(dict(zip(y_intervals, y_coords, strict=True))))
 
     # Set new MultiIndex with coordinates
     df_stats = df_stats.set_index([f"{x}", f"{y}"])

disdrodb/utils/decorators.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """DISDRODB decorators."""
+
 import functools
 import importlib
 import uuid
@@ -86,7 +85,7 @@ def single_threaded_if_parallel(function):
         if parallel:
             # Call function with single thread
             # with dask.config.set(scheduler='single-threaded'):
-            with dask.config.set(scheduler="synchronous"):
+            with dask.config.set(scheduler="single-threaded"):  # "synchronous"
                 result = function(*args, **kwargs)
         else:
             # Else run the function as usual

disdrodb/utils/dict.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

disdrodb/utils/directories.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,13 +15,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Define utilities for Directory/File Checks/Creation/Deletion."""
+
 import glob
 import logging
 import os
 import pathlib
 import shutil
 import subprocess
-from typing import Union
 
 from disdrodb.utils.list import flatten_list
 from disdrodb.utils.logger import log_info
@@ -81,7 +79,7 @@ def check_glob_pattern(pattern: str) -> None:
     return pattern
 
 
-def check_glob_patterns(patterns: Union[str, list]) -> list:
+def check_glob_patterns(patterns: str | list) -> list:
     """Check if glob patterns are valids."""
     if not isinstance(patterns, (str, list)):
         raise ValueError("'glob_patterns' must be a str or list of strings.")
@@ -212,7 +210,7 @@ def is_empty_directory(path, skip_hidden=True):
     return len(paths) == 0
 
 
-def _remove_file_or_directories(path, logger=None):
+def remove_file_or_directories(path, logger=None):
     """Return the file/directory or subdirectories tree of ``path``.
 
     Use this function with caution.
@@ -259,7 +257,7 @@ def remove_if_exists(path: str, force: bool = False, logger=None) -> None:
 
     # If force=True, remove the file/directory or subdirectories and files !
     try:
-        _remove_file_or_directories(path, logger=logger)
+        remove_file_or_directories(path, logger=logger)
     except Exception as e:
         msg = f"Can not delete file(s) at {path}. The error is: {e}"
         raise ValueError(msg)

disdrodb/utils/encoding.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """DISDRODB netCDF4 encoding utilities."""
+
 import os
 
 import numpy as np
@@ -128,7 +127,7 @@ def rechunk_dataset(ds: xr.Dataset, encodings_dict: dict) -> xr.Dataset:
             chunks = encodings_dict[var].get("chunksizes", None)  # .pop("chunksizes", None)
             if chunks is not None:
                 dims = list(ds[var].dims)
-                chunks_dict = dict(zip(dims, chunks))
+                chunks_dict = dict(zip(dims, chunks, strict=True))
                 ds[var] = ds[var].chunk(chunks_dict)
                 ds[var].encoding["chunksizes"] = chunks
     return ds
@@ -144,7 +143,7 @@ def get_time_encoding() -> dict:
     """
     encoding = {}
     encoding["dtype"] = "int64"  # if float trailing sub-seconds values
-    encoding["fillvalue"] = np.iinfo(np.int64).max
+    encoding["_FillValue"] = np.iinfo(np.int64).max
     encoding["units"] = EPOCH
     encoding["calendar"] = "proleptic_gregorian"
     return encoding

disdrodb/utils/event.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

disdrodb/utils/list.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

disdrodb/utils/logger.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

disdrodb/utils/manipulations.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -19,11 +17,184 @@
 """Include functions helping for DISDRODB product manipulations."""
 
 import numpy as np
+import xarray as xr
 
-from disdrodb.constants import DIAMETER_DIMENSION
+from disdrodb.constants import DIAMETER_DIMENSION, VELOCITY_DIMENSION
 from disdrodb.utils.xarray import unstack_datarray_dimension
 
 
+def define_diameter_datarray(bounds):
+    """Define diameter DataArray."""
+    diameters_bin_lower = bounds[:-1]
+    diameters_bin_upper = bounds[1:]
+    diameters_bin_width = diameters_bin_upper - diameters_bin_lower
+    diameters_bin_center = diameters_bin_lower + diameters_bin_width / 2
+    da = xr.DataArray(
+        diameters_bin_center,
+        dims="diameter_bin_center",
+        coords={
+            "diameter_bin_width": ("diameter_bin_center", diameters_bin_width),
+            "diameter_bin_lower": ("diameter_bin_center", diameters_bin_lower),
+            "diameter_bin_upper": ("diameter_bin_center", diameters_bin_upper),
+            "diameter_bin_center": ("diameter_bin_center", diameters_bin_center),
+        },
+    )
+    return da
+
+
+def define_velocity_datarray(bounds):
+    """Define velocity DataArray."""
+    velocitys_bin_lower = bounds[:-1]
+    velocitys_bin_upper = bounds[1:]
+    velocitys_bin_width = velocitys_bin_upper - velocitys_bin_lower
+    velocitys_bin_center = velocitys_bin_lower + velocitys_bin_width / 2
+    da = xr.DataArray(
+        velocitys_bin_center,
+        dims="velocity_bin_center",
+        coords={
+            "velocity_bin_width": ("velocity_bin_center", velocitys_bin_width),
+            "velocity_bin_lower": ("velocity_bin_center", velocitys_bin_lower),
+            "velocity_bin_upper": ("velocity_bin_center", velocitys_bin_upper),
+            "velocity_bin_center": ("velocity_bin_center", velocitys_bin_center),
+        },
+    )
+    return da
+
+
+def define_diameter_array(diameter_min=0, diameter_max=10, diameter_spacing=0.05):
+    """
+    Define an array of diameters and their corresponding bin properties.
+
+    Parameters
+    ----------
+    diameter_min : float, optional
+        The minimum diameter value. The default value is 0 mm.
+    diameter_max : float, optional
+        The maximum diameter value. The default value is 10 mm.
+    diameter_spacing : float, optional
+        The spacing between diameter values. The default value is 0.05 mm.
+
+    Returns
+    -------
+    xr.DataArray
+        A DataArray containing the center of each diameter bin, with coordinates for
+        the bin width, lower bound, upper bound, and center.
+
+    """
+    diameters_bounds = np.arange(diameter_min, diameter_max + diameter_spacing / 2, step=diameter_spacing)
+    return define_diameter_datarray(diameters_bounds)
+
+
+def define_velocity_array(velocity_min=0, velocity_max=10, velocity_spacing=0.05):
+    """
+    Define an array of velocities and their corresponding bin properties.
+
+    Parameters
+    ----------
+    velocity_min : float, optional
+        The minimum velocity value. The default value is 0 mm.
+    velocity_max : float, optional
+        The maximum velocity value. The default value is 10 mm.
+    velocity_spacing : float, optional
+        The spacing between velocity values. The default value is 0.05 mm.
+
+    Returns
+    -------
+    xr.DataArray
+        A DataArray containing the center of each velocity bin, with coordinates for
+        the bin width, lower bound, upper bound, and center.
+
+    """
+    velocitys_bounds = np.arange(velocity_min, velocity_max + velocity_spacing / 2, step=velocity_spacing)
+    return define_velocity_datarray(velocitys_bounds)
+
+
+def filter_diameter_bins(ds, minimum_diameter=None, maximum_diameter=None):
+    """
+    Filter the dataset to include only diameter bins within specified bounds.
+
+    Parameters
+    ----------
+    ds : xarray.Dataset
+        The dataset containing diameter bin data.
+    minimum_diameter : float, optional
+        The minimum diameter to be included, in millimeters.
+        Defaults to the minimum value in `ds["diameter_bin_lower"]`.
+    maximum_diameter : float, optional
+        The maximum diameter to be included, in millimeters.
+        Defaults to the maximum value in `ds["diameter_bin_upper"]`.
+
+    Returns
+    -------
+    xarray.Dataset
+        The filtered dataset containing only the specified diameter bins.
+    """
+    # Put data into memory
+    ds["diameter_bin_lower"] = ds["diameter_bin_lower"].compute()
+    ds["diameter_bin_upper"] = ds["diameter_bin_upper"].compute()
+
+    # Initialize default arguments
+    if minimum_diameter is None:
+        minimum_diameter = ds["diameter_bin_lower"].min().item()
+    if maximum_diameter is None:
+        maximum_diameter = ds["diameter_bin_upper"].max().item()
+
+    # Select bins which overlap the specified diameters
+    valid_indices = np.logical_and(
+        ds["diameter_bin_upper"] > minimum_diameter,
+        ds["diameter_bin_lower"] < maximum_diameter,
+    )
+    ds = ds.isel({DIAMETER_DIMENSION: valid_indices})
+
+    if ds.sizes[DIAMETER_DIMENSION] == 0:
+        msg = f"Filtering using {minimum_diameter=} removes all diameter bins."
+        raise ValueError(msg)
+    return ds
+
+
+def filter_velocity_bins(ds, minimum_velocity=None, maximum_velocity=None):
+    """
+    Filter the dataset to include only velocity bins within specified bounds.
+
+    Parameters
+    ----------
+    ds : xarray.Dataset
+        The dataset containing velocity bin data.
+    minimum_velocity : float, optional
+        The minimum velocity to include in the filter, in meters per second.
+        Defaults to the minimum value in `ds["velocity_bin_lower"]`.
+    maximum_velocity : float, optional
+        The maximum velocity to include in the filter, in meters per second.
+        Defaults to the maximum value in `ds["velocity_bin_upper"]`.
+
+    Returns
+    -------
+    xarray.Dataset
+        The filtered dataset containing only the specified velocity bins.
+    """
+    # Put data into memory
+    ds["velocity_bin_lower"] = ds["velocity_bin_lower"].compute()
+    ds["velocity_bin_upper"] = ds["velocity_bin_upper"].compute()
+
+    # Initialize default arguments
+    if minimum_velocity is None:
+        minimum_velocity = ds["velocity_bin_lower"].min().item()
+    if maximum_velocity is None:
+        maximum_velocity = ds["velocity_bin_upper"].max().item()
+
+    # Select bins which overlap the specified velocities
+    valid_indices = np.logical_and(
+        ds["velocity_bin_upper"] > minimum_velocity,
+        ds["velocity_bin_lower"] < maximum_velocity,
+    )
+
+    ds = ds.isel({VELOCITY_DIMENSION: valid_indices})
+    if ds.sizes[VELOCITY_DIMENSION] == 0:
+        msg = f"Filtering using {minimum_velocity=} removes all velocity bins."
+        raise ValueError(msg)
+    return ds
+
+
 def get_diameter_bin_edges(ds):
     """Retrieve diameter bin edges."""
     bin_edges = np.append(ds["diameter_bin_lower"].to_numpy(), ds["diameter_bin_upper"].to_numpy()[-1])