disdrodb 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

disdrodb/l1/beard_model.py

@@ -456,67 +456,67 @@ def get_raindrop_reynolds_number(diameter, temperature, air_density, water_densi
     return reynolds_number
 
 
-def get_fall_velocity_beard_1976(diameter, temperature, air_density, water_density, g):
+def get_drag_coefficient(diameter, air_density, water_density, fall_velocity, g=9.81):
     """
-    Computes the terminal fall velocity of a raindrop in still air.
-
-    Reference: Beard 1976; Pruppacher & Klett 1978
+    Computes the drag coefficient for a raindrop.
 
     Parameters
     ----------
     diameter : float
         Diameter of the raindrop in meters.
-    temperature : float
-        Temperature in Kelvin.
     air_density : float
         Density of air in kg/m^3.
     water_density : float
         Density of water in kg/m^3.
+    fall_velocity : float
+        Terminal fall velocity of the raindrop in m/s.
     g : float
         Gravitational acceleration in m/s^2.
 
     Returns
     -------
     float
-        Terminal fall velocity of the raindrop in m/s.
+        Drag coefficient of the raindrop.
     """
-    air_viscosity = get_air_dynamic_viscosity(temperature)
-    reynolds_number = get_raindrop_reynolds_number(
-        diameter=diameter,
-        temperature=temperature,
-        air_density=air_density,
-        water_density=water_density,
-        g=g,
-    )
-    fall_velocity = air_viscosity * reynolds_number / (air_density * diameter)
-    return fall_velocity
+    delta_density = water_density - air_density
+    drag_coefficient = 4 * delta_density * g * diameter / (3 * air_density * fall_velocity**2)
+    return drag_coefficient
 
 
-def get_drag_coefficient(diameter, air_density, water_density, fall_velocity, g=9.81):
+def get_fall_velocity_beard_1976(diameter, temperature, air_density, water_density, g):
     """
-    Computes the drag coefficient for a raindrop.
+    Computes the terminal fall velocity of a raindrop in still air.
+
+    Reference: Beard 1976; Pruppacher & Klett 1978
 
     Parameters
     ----------
     diameter : float
         Diameter of the raindrop in meters.
+    temperature : float
+        Temperature in Kelvin.
     air_density : float
         Density of air in kg/m^3.
     water_density : float
         Density of water in kg/m^3.
-    fall_velocity : float
-        Terminal fall velocity of the raindrop in m/s.
     g : float
         Gravitational acceleration in m/s^2.
 
     Returns
     -------
     float
-        Drag coefficient of the raindrop.
+        Terminal fall velocity of the raindrop in m/s.
     """
-    delta_density = water_density - air_density
-    drag_coefficient = 4 * delta_density * g * diameter / (3 * air_density * fall_velocity**2)
-    return drag_coefficient
+    air_viscosity = get_air_dynamic_viscosity(temperature)
+    reynolds_number = get_raindrop_reynolds_number(
+        diameter=diameter,
+        temperature=temperature,
+        air_density=air_density,
+        water_density=water_density,
+        g=g,
+    )
+    fall_velocity = air_viscosity * reynolds_number / (air_density * diameter)
+    return fall_velocity
 
 
 def retrieve_fall_velocity(
@@ -573,19 +573,24 @@ def retrieve_fall_velocity(
             gas_constant_dry_air=gas_constant_dry_air,
         )
 
+    # else
+    # --> Estimate sea_level_air_pressure from air_pressure ?
+
     # Retrieve vapour pressure (from relative humidity)
     vapor_pressure = get_vapor_actual_pressure(
         relative_humidity=relative_humidity,
         temperature=temperature,
     )
 
-    # Retrieve air density and water density
+    # Retrieve air density
     air_density = get_air_density(
         temperature=temperature,
         air_pressure=air_pressure,
         vapor_pressure=vapor_pressure,
         gas_constant_dry_air=gas_constant_dry_air,
     )
+
+    # Retrieve water density
     water_density = get_water_density(
         temperature=temperature,
         air_pressure=air_pressure,
@@ -611,106 +616,3 @@ def retrieve_fall_velocity(
     #                                         fall_velocity=fall_velocity)
 
     return fall_velocity
-
-
-####-----------------------------------------------------------------------------------------
-#### OLD CODE
-
-
-# def get_fall_velocity_beard_1977(diameter):
-#     """
-#     Compute the fall velocity of raindrops using the Beard (1977) relationship.
-
-#     Parameters
-#     ----------
-#     diameter : array-like
-#         Diameter of the raindrops in millimeters.
-#         Valid up to 7 mm (0.7 cm).
-
-#     Returns
-#     -------
-#     fall_velocity : array-like
-#         Fall velocities in meters per second.
-
-#     Notes
-#     -----
-#     This method uses an exponential function based on the work of Beard (1977),
-#     valid at sea level conditions (pressure = 1 atm, temperature = 20°C,
-#     air density = 1.194 kg/m³).
-
-#     References
-#     ----------
-#     Beard, K. V. (1977).
-#     Terminal velocity adjustment for cloud and precipitation drops aloft.
-#     Journal of the Atmospheric Sciences, 34(8), 1293-1298.
-#     https://doi.org/10.1175/1520-0469(1977)034<1293:TVAFCA>2.0.CO;2
-
-#     """
-#     diameter_cm = diameter/1000
-#     c = [7.06037, 1.74951, 4.86324, 6.60631, 4.84606, 2.14922, 0.58714, 0.096348, 0.00869209, 0.00033089]
-#     log_diameter = np.log(diameter_cm)
-#     y = c[0] + sum(c * log_diameter**i for i, c in enumerate(c[1:], start=1))
-#     fall_velocity = np.exp(y)
-#     return fall_velocity
-
-
-# def get_fall_velocity_beard_1977(diameter, temperature, air_pressure, gas_constant_dry_air=287.04):
-#     """
-#     Computes the terminal fall velocity of a raindrop in still air.
-
-#     This function is based on the Table 4 coefficients of Kenneth V. Beard (1977),
-#     "Terminal Velocity and Shape of Cloud and Precipitation Drops Aloft",
-#     Journal of the Atmospheric Sciences, Vol. 34, pp. 1293-1298.
-
-#     Note: This approximation is valid at sea level with conditions:
-#           Pressure = 1 atm, Temperature = 20°C, (saturated) air density = 1.194 kg/m³.
-
-#     Parameters
-#     ----------
-#     diameter : array-like
-#         Array of equivolume drop diameters in meters.
-
-#     Returns
-#     -------
-#     fall_velocity : array-like
-#         Array of terminal fall velocity in meters per second (m/s).
-#         For diameters greater than 7 mm, the function returns NaN.
-
-#     """
-#     # PROBLEMATIC
-#     # Compute sea level velocity
-#     c = [7.06037, 1.74951, 4.86324, 6.60631, 4.84606, 2.14922, 0.58714, 0.096348, 0.00869209, 0.00033089]
-#     log_diameter = np.log(diameter / 1000 * 10)
-#     y = c[0] + sum(c * log_diameter**i for i, c in enumerate(c[1:], start=1))
-#     v0 = np.exp(y)
-
-#     # Compute fall velocity
-#     t_20 = 273.15 + 20
-#     eps_s = get_air_dynamic_viscosity(t_20) / get_air_dynamic_viscosity(temperature) - 1
-#     eps_c = -1 + (
-#         np.sqrt(
-#             get_air_density(
-#                 temperature=t_20,
-#                 air_pressure=101325,
-#                 vapor_pressure=0,
-#                 gas_constant_dry_air=gas_constant_dry_air,
-#             )
-#             / get_air_density(
-#                 temperature=temperature,
-#                 air_pressure=air_pressure,
-#                 vapor_pressure=0,
-#                 gas_constant_dry_air=gas_constant_dry_air,
-#             ),
-#         )
-#     )
-#     a = 1.104 * eps_s
-#     b = (1.058 * eps_c - 1.104 * eps_s) / 5.01
-#     x = np.log(diameter) + 5.52
-#     f = (a + b * x) + 1
-#     fall_velocity = v0 * f
-#     # fall_velocity.plot()
-
-#     eps = 1.104 * eps_s + (1.058 * eps_c - 1.104 * eps_s) * np.log(diameter / 1e-3) / 5.01
-#     # eps = 1.104 * eps_s + (1.058 * eps_c - 1.104 * eps_s) * np.log(diameter / 4e-5) / 5.01
-#     fall_velocity = 0.01 * v0 * (1 + eps)
-#     return fall_velocity

disdrodb/l1/fall_velocity.py

@@ -14,10 +14,14 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
-"""Theoretical models to estimate the drop fall velocity."""
-
-
+"""Theoretical models to estimate the raindrop fall velocity based on drop diameter in mm."""
 import numpy as np
+import xarray as xr
+
+from disdrodb.constants import DIAMETER_DIMENSION
+from disdrodb.l0.l0b_processing import ensure_valid_geolocation
+from disdrodb.l1_env.routines import load_env_dataset
+from disdrodb.utils.warnings import suppress_warnings
 
 
 def get_fall_velocity_atlas_1973(diameter):
@@ -53,7 +57,7 @@ def get_fall_velocity_atlas_1973(diameter):
 
     """
     fall_velocity = 9.65 - 10.3 * np.exp(-0.6 * diameter)  # clip to 0 !
-    fall_velocity = np.clip(fall_velocity, 0, None)
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -80,6 +84,7 @@ def get_fall_velocity_brandes_2002(diameter):
 
     """
     fall_velocity = -0.1021 + 4.932 * diameter - 0.9551 * diameter**2 + 0.07934 * diameter**3 - 0.002362 * diameter**4
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -107,6 +112,7 @@ def get_fall_velocity_uplinger_1981(diameter):
     """
     # Valid between 0.1 and 7 mm
     fall_velocity = 4.874 * diameter * np.exp(-0.195 * diameter)
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -133,6 +139,7 @@ def get_fall_velocity_van_dijk_2002(diameter):
 
     """
     fall_velocity = -0.254 + 5.03 * diameter - 0.912 * diameter**2 + 0.0561 * diameter**3
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -147,9 +154,10 @@ def get_fall_velocity_beard_1976(diameter, ds_env):
         A dataset containing the following environmental variables:
         - 'altitude' :  Altitude in meters (m).
         - 'latitude' :  Latitude in degrees.
-        - 'temperature' : Temperature in degrees Celsius (°C).
+        - 'temperature' : Temperature in degrees Kelvin (K).
         - 'relative_humidity' :  Relative humidity in percentage (%).
         - 'sea_level_air_pressure' : Sea level air pressure in Pascals (Pa).
+        - 'air_pressure': Air pressure in Pascals (Pa).
         - 'lapse_rate' : Lapse rate in degrees Celsius per meter (°C/m).
 
     Returns
@@ -166,121 +174,171 @@ def get_fall_velocity_beard_1976(diameter, ds_env):
         latitude=ds_env["latitude"],
         temperature=ds_env["temperature"],
         relative_humidity=ds_env["relative_humidity"],
-        # TODO: add air_pressure # TODO
+        air_pressure=ds_env.get("air_pressure", None),
         sea_level_air_pressure=ds_env["sea_level_air_pressure"],
         lapse_rate=ds_env["lapse_rate"],
     )
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
-def ensure_valid_coordinates(ds, default_altitude=0, default_latitude=0, default_longitude=0):
-    """Ensure dataset valid coordinates for altitude, latitude, and longitude.
+RAINDROP_FALL_VELOCITY_MODELS = {
+    "Atlas1973": get_fall_velocity_atlas_1973,
+    "Beard1976": get_fall_velocity_beard_1976,
+    "Brandes2002": get_fall_velocity_brandes_2002,
+    "Uplinger1981": get_fall_velocity_uplinger_1981,
+    "VanDijk2002": get_fall_velocity_van_dijk_2002,
+}
+
+
+def available_raindrop_fall_velocity_models():
+    """Return a list of the available raindrop fall velocity models."""
+    return list(RAINDROP_FALL_VELOCITY_MODELS)
 
-    Invalid values are np.nan and -9999.
+
+def check_raindrop_fall_velocity_model(model):
+    """Check validity of the specified raindrop fall velocity model."""
+    available_models = available_raindrop_fall_velocity_models()
+    if model not in available_models:
+        raise ValueError(f"{model} is an invalid raindrop fall velocity model. Valid models: {available_models}.")
+    return model
+
+
+def get_raindrop_fall_velocity_model(model):
+    """Return the specified raindrop fall velocity model.
 
     Parameters
     ----------
-    ds : xarray.Dataset
-        The dataset for which to ensure valid geolocation coordinates.
-    default_altitude : float, optional
-        The default value to use for invalid altitude values. Defaults to 0.
-    default_latitude : float, optional
-        The default value to use for invalid latitude values. Defaults to 0.
-    default_longitude : float, optional
-        The default value to use for invalid longitude values. Defaults to 0.
+    model : str
+        The model to use for calculating the rain drop fall velocity. Available models are:
+       'Atlas1973', 'Beard1976', 'Brandes2002', 'Uplinger1981', 'VanDijk2002'.
 
     Returns
     -------
-    xarray.Dataset
-        The dataset with invalid coordinates replaced by default values.
+    callable
+        A function which compute the raindrop fall velocity model
+        given the rain drop diameter in mm.
 
+    Notes
+    -----
+    This function serves as a wrapper to various raindrop fall velocity models.
+    It returns the appropriate model based on the `model` parameter.
     """
-    # TODO raise error if not present
-    invalid_altitude = np.logical_or(np.isnan(ds["altitude"]), ds["altitude"] == -9999)
-    ds["altitude"] = ds["altitude"].where(~invalid_altitude, default_altitude)
-
-    invalid_lat = np.logical_or(np.isnan(ds["latitude"]), ds["latitude"] == -9999)
-    ds["latitude"] = ds["latitude"].where(~invalid_lat, default_latitude)
+    model = check_raindrop_fall_velocity_model(model)
+    return RAINDROP_FALL_VELOCITY_MODELS[model]
 
-    invalid_lon = np.logical_or(np.isnan(ds["longitude"]), ds["longitude"] == -9999)
-    ds["longitude"] = ds["longitude"].where(~invalid_lon, default_longitude)
-    return ds
 
-
-def get_raindrop_fall_velocity(diameter, method, ds_env=None):
+def get_raindrop_fall_velocity(diameter, model, ds_env=None):
     """Calculate the fall velocity of raindrops based on their diameter.
 
     Parameters
     ----------
     diameter : array-like
         The diameter of the raindrops in millimeters.
-    method : str
-        The method to use for calculating the fall velocity. Must be one of the following:
+    model : str
+        The model to use for calculating the raindrop fall velocity. Must be one of the following:
         'Atlas1973', 'Beard1976', 'Brandes2002', 'Uplinger1981', 'VanDijk2002'.
     ds_env : xr.Dataset, optional
+        Only required if model is 'Beard1976'.
         A dataset containing the following environmental variables:
-        - 'altitude' :  Altitude in meters (m).
-        - 'latitude' :  Latitude in degrees.
-        - 'temperature' : Temperature in degrees Celsius (°C).
+        - 'altitude' (m)
+        - 'latitude' (°)
+        - 'temperature' : Temperature in degrees Kelvin (K).
         - 'relative_humidity' :  Relative humidity. A value between 0 and 1.
         - 'sea_level_air_pressure' : Sea level air pressure in Pascals (Pa).
         - 'lapse_rate' : Lapse rate in degrees Celsius per meter (°C/m).
-        It is required for for the 'Beard1976' method.
+        If not specified, sensible default values are used.
 
     Returns
     -------
-    fall_velocity : array-like
-        The calculated fall velocities of the raindrops.
+    fall_velocity : xr.DataArray
+        The calculated raindrop fall velocities per diameter.
 
     Notes
     -----
-    The 'Beard1976' method requires additional environmental parameters such as altitude and latitude.
-    These parameters can be provided through the `ds_env` argument. If not provided, default values will be used.
+    The 'Beard1976' model requires additional environmental parameters.
+    These parameters can be provided through the `ds_env` argument.
+    If not provided, default values are be used.
+
+    For D < 0.12, Atlas1973 relationship results output V = 0 m/s  !
+    For D < 0.05, VanDijk2002 relationship results output V = 0 m/s !
+    For D < 0.02, Brandes relationship results output V = 0 m/s !
+
     """
-    # Input diameter in mm
-    dict_methods = {
-        "Atlas1973": get_fall_velocity_atlas_1973,
-        "Beard1976": get_fall_velocity_beard_1976,
-        "Brandes2002": get_fall_velocity_brandes_2002,
-        "Uplinger1981": get_fall_velocity_uplinger_1981,
-        "VanDijk2002": get_fall_velocity_van_dijk_2002,
-    }
     # Check valid method
-    available_methods = list(dict_methods)
-    if method not in dict_methods:
-        raise ValueError(f"{method} is an invalid fall velocity method. Valid methods: {available_methods}.")
-    # Copy diameter
-    diameter = diameter.copy()
-    # Initialize ds_env if None
-    # if ds_env is None:
-    #     ds_env = load_env_dataset(ds_env)
+    model = check_raindrop_fall_velocity_model(model)
 
-    # TODO: wrapper for DISDRODB product !
+    # Copy diameter
+    if isinstance(diameter, xr.DataArray):
+        diameter = diameter.copy()
+    else:
+        diameter = np.atleast_1d(diameter)
+        diameter = xr.DataArray(diameter, dims=DIAMETER_DIMENSION, coords={DIAMETER_DIMENSION: diameter.copy()})
+
+    # Initialize ds_env if None and method == "Beard1976"
+    if model == "Beard1976":
+        if ds_env is None:
+            ds_env = load_env_dataset()
+
+        # Ensure valid altitude and geolocation
+        # - altitude required by Beard
+        # - latitude required for gravity
+        for coord in ["altitude", "latitude"]:
+            ds_env = ensure_valid_geolocation(ds_env, coord=coord, errors="raise")
 
-    # Ensure valid altitude and geolocation (if missing set defaults)
-    # - altitude required by Beard
-    # - latitude required for gravity
-    ds_env = ensure_valid_coordinates(ds_env)
     # Retrieve fall velocity
-    func = dict_methods[method]
-    fall_velocity = func(diameter, ds_env=ds_env) if method == "Beard1976" else func(diameter)
-    return fall_velocity
+    func = get_raindrop_fall_velocity_model(model)
+    with suppress_warnings():  # e.g. when diameter = 0 for Beard1976
+        fall_velocity = func(diameter, ds_env=ds_env) if model == "Beard1976" else func(diameter)
+
+    # Set to NaN for diameter outside [0, 10)
+    fall_velocity = fall_velocity.where(diameter < 10).where(diameter > 0)
+    # Ensure fall velocity is > 0 to avoid division by zero
+    # - Some models, at small diameter, can return negative/zero fall velocity
+    fall_velocity = fall_velocity.where(fall_velocity > 0)
 
+    # Add attributes
+    fall_velocity.name = "fall_velocity"
+    fall_velocity.attrs["units"] = "m/s"
+    fall_velocity.attrs["model"] = model
+    return fall_velocity.squeeze()
 
-def get_dataset_fall_velocity(ds, method="Brandes2002"):
-    """Compute the fall velocity and add it to the dataset.
+
+def get_raindrop_fall_velocity_from_ds(ds, ds_env=None, model="Beard1976"):
+    """Compute the raindrop fall velocity.
 
     Parameters
     ----------
     ds : xarray.Dataset
-        DISDRODB L0C dataset.
-    method : str, optional
-        Method to compute fall velocity. The default method is ``"Brandes2002"``.
+        DISDRODB dataset with the ``'diameter_bin_center'`` coordinate.
+        The ``'altitude'`` and ``'latitude'`` coordinates are used if ``model='Beard1976'``.
+    model : str, optional
+        Model to compute rain drop fall velocity.
+        The default model is ``"Beard1976"``.
+    ds_env : xr.Dataset, optional
+        Only required if model is 'Beard1976'.
+        A dataset containing the following environmental variables:
+        - 'temperature' : Temperature in degrees Kelvin (K).
+        - 'relative_humidity' :  Relative humidity. A value between 0 and 1.
+        - 'sea_level_air_pressure' : Sea level air pressure in Pascals (Pa).
+        - 'lapse_rate' : Lapse rate in degrees Celsius per meter (°C/m).
+        If not specified, sensible default values are used.
 
     Returns
     -------
-    xarray.Dataset
-        DISDRODB L0C dataset with an additional variable 'fall_velocity'.
+    xarray.DataArray
+        Rain drop fall velocity DataArray.
+
+    Notes
+    -----
+    The 'Beard1976' model requires additional environmental parameters.
+    These parameters can be provided through the `ds_env` argument.
+    If not provided, default values are be used.
+
+    For D < 0.12, Atlas1973 relationship results output V = 0 m/s
+    For D < 0.05, VanDijk2002 relationship results output V = 0 m/s
+    For D < 0.02, Brandes relationship results output V = 0 m/s
+
     """
     from disdrodb.constants import DIAMETER_DIMENSION
     from disdrodb.l1_env.routines import load_env_dataset
@@ -289,18 +347,13 @@ def get_dataset_fall_velocity(ds, method="Brandes2002"):
     if DIAMETER_DIMENSION not in ds.dims:
         raise ValueError(f"Diameter dimension '{DIAMETER_DIMENSION}' not found in dataset dimensions.")
 
-    # Retrieve diameter values (in mm)
-    diameter_bin_center = ds["diameter_bin_center"]
-
-    # Ensure valid altitude and geolocation (if missing set defaults)
-    # TODO: MOBILE CASE !
-    default_geolocation = {"altitude": 0, "latitude": 0, "longitude": 0}
-    dataset_coords = {key: ds[key] for key in default_geolocation if key in ds}
-    default_geolocation.update(dataset_coords)
-    ds = ds.assign_coords(default_geolocation)
+    # Retrieve ENV dataset
+    # - It checks and includes default geolocation if missing
+    # - For mobile disdrometer, infill missing geolocation with backward and forward filling
+    if ds_env is None:
+        ds_env = load_env_dataset(ds)
 
-    # TODO: deal with ENV dataset
-    ds_env = load_env_dataset(ds)
+    # Compute raindrop fall velocity
+    fall_velocity = get_raindrop_fall_velocity(diameter=ds["diameter_bin_center"], model=model, ds_env=ds_env)  # mn
 
-    fall_velocity = get_raindrop_fall_velocity(diameter_bin_center, method=method, ds_env=ds_env)
     return fall_velocity

disdrodb/l1/filters.py

@@ -57,17 +57,15 @@ def filter_diameter_bins(ds, minimum_diameter=None, maximum_diameter=None):
         ds["diameter_bin_upper"] > minimum_diameter,
         ds["diameter_bin_lower"] < maximum_diameter,
     )
-
-    # Select bins with diameter values entirely inside the specified min/max values
-    # valid_indices = np.logical_and(
-    #     ds["diameter_bin_lower"] >= minimum_diameter,
-    #     ds["diameter_bin_upper"] <= 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=0, maximum_velocity=12):
+def filter_velocity_bins(ds, minimum_velocity=None, maximum_velocity=None):
     """
     Filter the dataset to include only velocity bins within specified bounds.
 
@@ -77,10 +75,10 @@ def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
         The dataset containing velocity bin data.
     minimum_velocity : float, optional
         The minimum velocity to include in the filter, in meters per second.
-        Defaults to 0 m/s.
+        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 12 m/s.
+        Defaults to the maximum value in `ds["velocity_bin_upper"]`.
 
     Returns
     -------
@@ -103,16 +101,14 @@ def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
         ds["velocity_bin_lower"] < maximum_velocity,
     )
 
-    # Select bins with velocity values entirely inside the specified min/max values
-    # valid_indices = np.logical_and(
-    #     ds["velocity_bin_lower"] >= minimum_velocity,
-    #     ds["velocity_bin_upper"] <= 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 define_spectrum_mask(
+def define_raindrop_spectrum_mask(
     drop_number,
     fall_velocity,
     above_velocity_fraction=None,
@@ -130,29 +126,29 @@ def define_spectrum_mask(
     drop_number : xarray.DataArray
         Array of drop counts per diameter and velocity bins.
     fall_velocity : array-like
-        The expected terminal fall velocities for drops of given sizes.
+        The expected terminal fall velocities for rain drops of given sizes.
     above_velocity_fraction : float, optional
-        Fraction of terminal fall velocity above which drops are considered too fast.
+        Fraction of terminal fall velocity above which rain drops are considered too fast.
         Either specify ``above_velocity_fraction`` or ``above_velocity_tolerance``.
     above_velocity_tolerance : float, optional
-        Absolute tolerance above which drops terminal fall velocities are considered too fast.
+        Absolute tolerance above which rain drops terminal fall velocities are considered too fast.
         Either specify ``above_velocity_fraction`` or ``above_velocity_tolerance``.
     below_velocity_fraction : float, optional
-        Fraction of terminal fall velocity below which drops are considered too slow.
+        Fraction of terminal fall velocity below which rain drops are considered too slow.
         Either specify ``below_velocity_fraction`` or ``below_velocity_tolerance``.
     below_velocity_tolerance : float, optional
-        Absolute tolerance below which drops terminal fall velocities are considered too slow.
+        Absolute tolerance below which rain drops terminal fall velocities are considered too slow.
          Either specify ``below_velocity_fraction`` or ``below_velocity_tolerance``.
     maintain_smallest : bool, optional
-        If True, ensures that the small drops in the spectrum are retained in the mask.
-        The smallest drops are characterized by ``small_diameter_threshold``
+        If True, ensures that the small rain drops in the spectrum are retained in the mask.
+        The smallest rain drops are characterized by ``small_diameter_threshold``
         and ``small_velocity_threshold`` arguments.
         Defaults to False.
     small_diameter_threshold : float, optional
-        The diameter threshold to use for keeping the smallest drop.
+        The diameter threshold to use for keeping the smallest rain drop.
         Defaults to 1 mm.
     small_velocity_threshold : float, optional
-        The fall velocity threshold to use for keeping the smallest drops.
+        The fall velocity threshold to use for keeping the smallest rain drops.
         Defaults to 2.5 m/s.
 
     Returns
@@ -178,6 +174,7 @@ def define_spectrum_mask(
         above_fall_velocity = fall_velocity + above_velocity_tolerance
     else:
         above_fall_velocity = np.inf
+
     if below_velocity_fraction is not None:
         below_fall_velocity = fall_velocity * (1 - below_velocity_fraction)
     elif below_velocity_tolerance is not None:
@@ -191,15 +188,15 @@ def define_spectrum_mask(
 
     # Define mask
     mask = np.logical_and(
-        np.logical_or(velocity_lower >= below_fall_velocity, velocity_upper >= below_fall_velocity),
-        np.logical_or(velocity_lower <= above_fall_velocity, velocity_upper <= above_fall_velocity),
+        velocity_upper > below_fall_velocity,
+        velocity_lower < above_fall_velocity,
     )
 
     # Maintant smallest drops
     if maintain_smallest_drops:
         mask_smallest = np.logical_and(
-            drop_number["diameter_bin_upper"] < small_diameter_threshold,
-            drop_number["velocity_bin_upper"] < small_velocity_threshold,
+            drop_number["diameter_bin_upper"] <= small_diameter_threshold,
+            drop_number["velocity_bin_upper"] <= small_velocity_threshold,
         )
         mask = np.logical_or(mask, mask_smallest)