disdrodb 0.0.20__py3-none-any.whl → 0.1.0__py3-none-any.whl

disdrodb/l1/fall_velocity.py

@@ -0,0 +1,260 @@
+# -----------------------------------------------------------------------------.
+# Copyright (c) 2021-2023 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/>.
+# -----------------------------------------------------------------------------.
+"""Theoretical models to estimate the drop fall velocity."""
+
+
+import numpy as np
+
+
+def get_fall_velocity_atlas_1973(diameter):
+    """
+    Compute the fall velocity of raindrops using the Atlas et al. (1973) relationship.
+
+    Parameters
+    ----------
+    diameter : array-like
+        Diameter of the raindrops in millimeters.
+
+    Returns
+    -------
+    fall_velocity : array-like
+        Fall velocities corresponding to the input diameters, in meters per second.
+
+    References
+    ----------
+    Atlas, D., Srivastava, R. C., & Sekhon, R. S. (1973).
+    Doppler radar characteristics of precipitation at vertical incidence.
+    Reviews of Geophysics, 11(1), 1-35.
+    https://doi.org/10.1029/RG011i001p00001
+
+    Atlas, D., & Ulbrich, C. W. (1977).
+    Path- and area-integrated rainfall measurement by microwave attenuation in the 1-3 cm band.
+    Journal of Applied Meteorology, 16(12), 1322-1331.
+    https://doi.org/10.1175/1520-0450(1977)016<1322:PAAIRM>2.0.CO;2
+
+    Gunn, R., & Kinzer, G. D. (1949).
+    The terminal velocity of fall for water droplets in stagnant air.
+    Journal of Meteorology, 6(4), 243-248.
+    https://doi.org/10.1175/1520-0469(1949)006<0243:TTVOFF>2.0.CO;2
+
+    """
+    fall_velocity = 9.65 - 10.3 * np.exp(-0.6 * diameter)  # clip to 0 !
+    fall_velocity = np.clip(fall_velocity, 0, None)
+    return fall_velocity
+
+
+def get_fall_velocity_brandes_2002(diameter):
+    """
+    Compute the fall velocity of raindrops using the Brandes et al. (2002) relationship.
+
+    Parameters
+    ----------
+    diameter : array-like
+        Diameter of the raindrops in millimeters.
+
+    Returns
+    -------
+    fall_velocity : array-like
+        Fall velocities in meters per second.
+
+    References
+    ----------
+    Brandes, E. A., Zhang, G., & Vivekanandan, J. (2002).
+    Experiments in rainfall estimation with a polarimetric radar in a subtropical environment.
+    Journal of Applied Meteorology, 41(6), 674-685.
+    https://doi.org/10.1175/1520-0450(2002)041<0674:EIREWA>2.0.CO;2
+
+    """
+    fall_velocity = -0.1021 + 4.932 * diameter - 0.9551 * diameter**2 + 0.07934 * diameter**3 - 0.002362 * diameter**4
+    return fall_velocity
+
+
+def get_fall_velocity_uplinger_1981(diameter):
+    """
+    Compute the fall velocity of raindrops using Uplinger (1981) relationship.
+
+    Parameters
+    ----------
+    diameter : array-like
+        Diameter of the raindrops in millimeters.
+        Valid for diameters between 0.1 mm and 7 mm.
+
+    Returns
+    -------
+    fall_velocity : array-like
+        Fall velocities in meters per second.
+
+    References
+    ----------
+    Uplinger, C. W. (1981). A new formula for raindrop terminal velocity.
+    In Proceedings of the 20th Conference on Radar Meteorology (pp. 389-391).
+    AMS.
+
+    """
+    # Valid between 0.1 and 7 mm
+    fall_velocity = 4.874 * diameter * np.exp(-0.195 * diameter)
+    return fall_velocity
+
+
+def get_fall_velocity_van_dijk_2002(diameter):
+    """
+    Compute the fall velocity of raindrops using van Dijk et al. (2002) relationship.
+
+    Parameters
+    ----------
+    diameter : array-like
+        Diameter of the raindrops in millimeters.
+
+    Returns
+    -------
+    fall_velocity : array-like
+        Fall velocities in meters per second.
+
+    References
+    ----------
+    van Dijk, A. I. J. M., Bruijnzeel, L. A., & Rosewell, C. J. (2002).
+    Rainfall intensity-kinetic energy relationships: a critical literature appraisal.
+    Journal of Hydrology, 261(1-4), 1-23.
+    https://doi.org/10.1016/S0022-1694(02)00020-3
+
+    """
+    fall_velocity = -0.254 + 5.03 * diameter - 0.912 * diameter**2 + 0.0561 * diameter**3
+    return fall_velocity
+
+
+def get_fall_velocity_beard_1976(diameter, ds_env):
+    """Calculate the fall velocity of a particle using the Beard (1976) model.
+
+    Parameters
+    ----------
+    diameter : array-like
+        Diameter of the raindrops in millimeters.
+    ds_env : xr.Dataset
+        A dataset containing the following environmental variables:
+        - 'altitude' :  Altitude in meters (m).
+        - 'latitude' :  Latitude in degrees.
+        - 'temperature' : Temperature in degrees Celsius (°C).
+        - 'relative_humidity' :  Relative humidity in percentage (%).
+        - 'sea_level_air_pressure' : Sea level air pressure in Pascals (Pa).
+        - 'lapse_rate' : Lapse rate in degrees Celsius per meter (°C/m).
+
+    Returns
+    -------
+    fall_velocity : array-like
+        The calculated fall velocities of the raindrops.
+    """
+    from disdrodb.l1.beard_model import retrieve_fall_velocity
+
+    # Input diameter in mmm
+    fall_velocity = retrieve_fall_velocity(
+        diameter=diameter / 1000,  # diameter expected in m !!!
+        altitude=ds_env["altitude"],
+        latitude=ds_env["latitude"],
+        temperature=ds_env["temperature"],
+        relative_humidity=ds_env["relative_humidity"],
+        # TODO: add air_pressure # TODO
+        sea_level_air_pressure=ds_env["sea_level_air_pressure"],
+        lapse_rate=ds_env["lapse_rate"],
+    )
+    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.
+
+    Invalid values are np.nan and -9999.
+
+    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.
+
+    Returns
+    -------
+    xarray.Dataset
+        The dataset with invalid coordinates replaced by default values.
+
+    """
+    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)
+
+    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):
+    """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:
+        'Atlas1973', 'Beard1976', 'Brandes2002', 'Uplinger1981', 'VanDijk2002'.
+    ds_env : xr.Dataset, optional
+        A dataset containing the following environmental variables:
+        - 'altitude' :  Altitude in meters (m).
+        - 'latitude' :  Latitude in degrees.
+        - 'temperature' : Temperature in degrees Celsius (°C).
+        - '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.
+
+    Returns
+    -------
+    fall_velocity : array-like
+        The calculated fall velocities of the raindrops.
+
+    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.
+    """
+    # 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()
+    # 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

disdrodb/l1/filters.py

@@ -0,0 +1,192 @@
+# -----------------------------------------------------------------------------.
+# Copyright (c) 2021-2023 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/>.
+# -----------------------------------------------------------------------------.
+"""Utilities for filtering the disdrometer raw drop spectra."""
+
+import numpy as np
+import xarray as xr
+
+
+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 include in the filter, in millimeters.
+        Defaults to the minimum value in `ds["diameter_bin_lower"]`.
+    maximum_diameter : float, optional
+        The maximum diameter to include in the filter, in millimeters.
+        Defaults to the maximum value in `ds["diameter_bin_upper"]`.
+
+    Returns
+    -------
+    xarray.Dataset
+        The filtered dataset containing only the specified diameter bins.
+    """
+    # 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 valid bins
+    valid_indices = np.logical_and(
+        ds["diameter_bin_lower"] >= minimum_diameter,
+        ds["diameter_bin_upper"] <= maximum_diameter,
+    )
+    ds = ds.isel({"diameter_bin_center": valid_indices})
+    # Update history
+    history = ds.attrs.get("history", "")
+    ds.attrs["history"] = (
+        history + f" Selected drops with diameters between {minimum_diameter} and {maximum_diameter} mm \n"
+    )
+    return ds
+
+
+def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
+    """
+    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 0 m/s.
+    maximum_velocity : float, optional
+        The maximum velocity to include in the filter, in meters per second.
+        Defaults to 12 m/s.
+
+    Returns
+    -------
+    xarray.Dataset
+        The filtered dataset containing only the specified velocity bins.
+    """
+    # 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 valid bins
+    valid_indices = np.logical_and(
+        ds["velocity_bin_lower"] >= minimum_velocity,
+        ds["velocity_bin_upper"] <= maximum_velocity,
+    )
+    ds = ds.isel({"velocity_bin_center": valid_indices})
+    # Update history
+    history = ds.attrs.get("history", "")
+    ds.attrs["history"] = (
+        history + f" Selected drops with fall velocity between {minimum_velocity} and {maximum_velocity} m/s \n"
+    )
+    return ds
+
+
+def define_spectrum_mask(
+    drop_number,
+    fall_velocity,
+    above_velocity_fraction=None,
+    above_velocity_tolerance=None,
+    below_velocity_fraction=None,
+    below_velocity_tolerance=None,
+    small_diameter_threshold=1,  # 1,   # 2
+    small_velocity_threshold=2.5,  # 2.5, # 3
+    maintain_smallest_drops=False,
+):
+    """Define a mask for the drop spectrum based on fall velocity thresholds.
+
+    Parameters
+    ----------
+    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.
+    above_velocity_fraction : float, optional
+        Fraction of terminal fall velocity above which 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.
+        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.
+        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.
+         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``
+        and ``small_velocity_threshold`` arguments.
+        Defaults to False.
+    small_diameter_threshold : float, optional
+        The diameter threshold to use for keeping the smallest drop.
+        Defaults to 1 mm.
+    small_velocity_threshold : float, optional
+        The fall velocity threshold to use for keeping the smallest drops.
+        Defaults to 2.5 m/s.
+
+    Returns
+    -------
+    xarray.DataArray
+        A boolean mask array indicating valid bins according to the specified criteria.
+
+    """
+    # Ensure it creates a 2D mask if the fall_velocity does not vary over time
+    if "time" in drop_number.dims and "time" not in fall_velocity.dims:
+        drop_number = drop_number.isel(time=0)
+
+    # Check arguments
+    if above_velocity_fraction is not None and above_velocity_tolerance is not None:
+        raise ValueError("Either specify 'above_velocity_fraction' or 'above_velocity_tolerance'.")
+    if below_velocity_fraction is not None and below_velocity_tolerance is not None:
+        raise ValueError("Either specify 'below_velocity_fraction' or 'below_velocity_tolerance'.")
+
+    # Define above/below velocity thresholds
+    if above_velocity_fraction is not None:
+        above_fall_velocity = fall_velocity * (1 + above_velocity_fraction)
+    elif above_velocity_tolerance is not None:
+        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:
+        below_fall_velocity = fall_velocity - below_velocity_tolerance
+    else:
+        below_fall_velocity = 0
+
+    # Define velocity 2D array
+    velocity_lower = xr.ones_like(drop_number) * drop_number["velocity_bin_lower"]
+    velocity_upper = xr.ones_like(drop_number) * drop_number["velocity_bin_upper"]
+
+    # 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),
+    )
+
+    # 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,
+        )
+        mask = np.logical_or(mask, mask_smallest)
+
+    return mask

disdrodb/l1/processing.py

@@ -0,0 +1,200 @@
+# -----------------------------------------------------------------------------.
+# Copyright (c) 2021-2023 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/>.
+# -----------------------------------------------------------------------------.
+"""Core functions for DISDRODB L1 production."""
+
+
+import xarray as xr
+
+from disdrodb import DIAMETER_DIMENSION, VELOCITY_DIMENSION
+from disdrodb.l1.encoding_attrs import get_attrs_dict, get_encoding_dict
+from disdrodb.l1.fall_velocity import get_raindrop_fall_velocity
+from disdrodb.l1.filters import define_spectrum_mask, filter_diameter_bins, filter_velocity_bins
+from disdrodb.l1.resampling import add_sample_interval
+from disdrodb.l1_env.routines import load_env_dataset
+from disdrodb.l2.empirical_dsd import (  # TODO: maybe move out of L2
+    count_bins_with_drops,
+    get_min_max_diameter,
+)
+from disdrodb.utils.attrs import set_attrs
+from disdrodb.utils.encoding import set_encodings
+from disdrodb.utils.time import ensure_sample_interval_in_seconds, infer_sample_interval
+
+
+def generate_l1(
+    ds,
+    # Fall velocity option
+    fall_velocity_method="Beard1976",
+    # Diameter-Velocity Filtering Options
+    minimum_diameter=0,
+    maximum_diameter=10,
+    minimum_velocity=0,
+    maximum_velocity=12,
+    above_velocity_fraction=0.5,
+    above_velocity_tolerance=None,
+    below_velocity_fraction=0.5,
+    below_velocity_tolerance=None,
+    small_diameter_threshold=1,  # 2
+    small_velocity_threshold=2.5,  # 3
+    maintain_smallest_drops=True,
+):
+    """Generate the DISDRODB L1 dataset from the DISDRODB L0C dataset.
+
+    Parameters
+    ----------
+    ds : xarray.Dataset
+        DISDRODB L0C dataset.
+    fall_velocity_method : str, optional
+        Method to compute fall velocity.
+        The default method is ``"Beard1976"``.
+    minimum_diameter : float, optional
+        Minimum diameter for filtering. The default value is 0 mm.
+    maximum_diameter : float, optional
+        Maximum diameter for filtering. The default value is 10 mm.
+    minimum_velocity : float, optional
+        Minimum velocity for filtering. The default value is 0 m/s.
+    maximum_velocity : float, optional
+        Maximum velocity for filtering. The default value is 12 m/s.
+    above_velocity_fraction : float, optional
+        Fraction of drops above velocity threshold. The default value is 0.5.
+    above_velocity_tolerance : float or None, optional
+        Tolerance for above velocity filtering. The default value is ``None``.
+    below_velocity_fraction : float, optional
+        Fraction of drops below velocity threshold. The default value is 0.5.
+    below_velocity_tolerance : float or None, optional
+        Tolerance for below velocity filtering. The default value is ``None``.
+    small_diameter_threshold : float, optional
+        Threshold for small diameter drops. The default value is 1.
+    small_velocity_threshold : float, optional
+        Threshold for small velocity drops. The default value is 2.5.
+    maintain_smallest_drops : bool, optional
+        Whether to maintain the smallest drops. The default value is ``True``.
+
+    Returns
+    -------
+    xarray.Dataset
+        DISRODB L1 dataset.
+    """
+    # Take as input an L0 !
+
+    # Retrieve source attributes
+    attrs = ds.attrs.copy()
+
+    # Determine if the velocity dimension is available
+    has_velocity_dimension = VELOCITY_DIMENSION in ds.dims
+
+    # Initialize L2 dataset
+    ds_l1 = xr.Dataset()
+
+    # Retrieve sample interval
+    # --> sample_interval is a coordinate of L0C products
+    if "sample_interval" in ds:
+        sample_interval = ensure_sample_interval_in_seconds(ds["sample_interval"].data)
+    else:
+        # This line is not called in the DISDRODB processing chain !
+        sample_interval = infer_sample_interval(ds, verbose=False)
+
+    # Re-add sample interval as coordinate (in seconds)
+    ds = add_sample_interval(ds, sample_interval=sample_interval)
+
+    # ---------------------------------------------------------------------------
+    # Retrieve ENV dataset or take defaults
+    # --> Used only for Beard fall velocity currently !
+    ds_env = load_env_dataset(ds)
+
+    # -------------------------------------------------------------------------------------------
+    # Filter dataset by diameter and velocity bins
+    # - Filter diameter bins
+    ds = filter_diameter_bins(ds=ds, minimum_diameter=minimum_diameter, maximum_diameter=maximum_diameter)
+    # - Filter velocity bins
+    if has_velocity_dimension:
+        ds = filter_velocity_bins(ds=ds, minimum_velocity=minimum_velocity, maximum_velocity=maximum_velocity)
+
+    # -------------------------------------------------------------------------------------------
+    # Compute fall velocity
+    fall_velocity = get_raindrop_fall_velocity(
+        diameter=ds["diameter_bin_center"],
+        method=fall_velocity_method,
+        ds_env=ds_env,  # mm
+    )
+
+    # Add fall velocity
+    ds_l1["fall_velocity"] = fall_velocity
+
+    # -------------------------------------------------------------------------------------------
+    # Define filtering mask according to fall velocity
+    if has_velocity_dimension:
+        mask = define_spectrum_mask(
+            drop_number=ds["raw_drop_number"],
+            fall_velocity=fall_velocity,
+            above_velocity_fraction=above_velocity_fraction,
+            above_velocity_tolerance=above_velocity_tolerance,
+            below_velocity_fraction=below_velocity_fraction,
+            below_velocity_tolerance=below_velocity_tolerance,
+            small_diameter_threshold=small_diameter_threshold,
+            small_velocity_threshold=small_velocity_threshold,
+            maintain_smallest_drops=maintain_smallest_drops,
+        )
+
+    # -------------------------------------------------------------------------------------------
+    # Retrieve drop number and drop_counts arrays
+    if has_velocity_dimension:
+        drop_number = ds["raw_drop_number"].where(mask)  # 2D (diameter, velocity)
+        drop_counts = drop_number.sum(dim=VELOCITY_DIMENSION)  # 1D (diameter)
+        drop_counts_raw = ds["raw_drop_number"].sum(dim=VELOCITY_DIMENSION)  # 1D (diameter)
+
+    else:
+        drop_number = ds["raw_drop_number"]  # 1D (diameter)
+        drop_counts = ds["raw_drop_number"]  # 1D (diameter)
+        drop_counts_raw = ds["raw_drop_number"]
+
+    # Add drop number and drop_counts
+    ds_l1["drop_number"] = drop_number
+    ds_l1["drop_counts"] = drop_counts
+
+    # -------------------------------------------------------------------------------------------
+    # Compute minimum and max drop diameter observed
+    min_drop_diameter, max_drop_diameter = get_min_max_diameter(drop_counts)
+
+    # Add drop statistics
+    ds_l1["Dmin"] = min_drop_diameter
+    ds_l1["Dmax"] = max_drop_diameter
+    ds_l1["n_drops_selected"] = drop_counts.sum(dim=DIAMETER_DIMENSION)
+    ds_l1["n_drops_discarded"] = drop_counts_raw.sum(dim=DIAMETER_DIMENSION) - ds_l1["n_drops_selected"]
+    ds_l1["n_bins_with_drops"] = count_bins_with_drops(ds_l1)
+
+    # -------------------------------------------------------------------------------------------
+    # Add quality flags
+    # TODO: snow_flags, insects_flag, ...
+
+    # -------------------------------------------------------------------------------------------
+    #### Add L0C coordinates that might got lost
+    if "time_qc" in ds:
+        ds_l1 = ds_l1.assign_coords({"time_qc": ds["time_qc"]})
+
+    #### ----------------------------------------------------------------------------.
+    #### Add encodings and attributes
+    # Add variables attributes
+    attrs_dict = get_attrs_dict()
+    ds_l1 = set_attrs(ds_l1, attrs_dict=attrs_dict)
+
+    # Add variables encoding
+    encoding_dict = get_encoding_dict()
+    ds_l1 = set_encodings(ds_l1, encoding_dict=encoding_dict)
+
+    # Add global attributes
+    ds_l1.attrs = attrs
+    return ds_l1