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

disdrodb/utils/archiving.py

@@ -23,10 +23,7 @@ import pandas as pd
 from disdrodb.api.info import get_start_end_time_from_filepaths
 from disdrodb.api.io import open_netcdf_files
 from disdrodb.utils.event import group_timesteps_into_event
-from disdrodb.utils.time import (
-    ensure_sorted_by_time,
-    ensure_timedelta_seconds,
-)
+from disdrodb.utils.time import ensure_sorted_by_time, temporal_resolution_to_seconds
 
 ####---------------------------------------------------------------------------------
 #### Time blocks
@@ -140,6 +137,7 @@ def identify_events(
     neighbor_time_interval : str
         The time interval around a given a timestep defining the neighborhood.
         Only timesteps that fall within this time interval before or after a timestep are considered neighbors.
+        The neighbor_time_interval must be at least equal to the dataset sampling interval!
     neighbor_min_size : int, optional
         The minimum number of neighboring timesteps required within `neighbor_time_interval` for a
         timestep to be considered non-isolated.  Isolated timesteps are removed !
@@ -171,6 +169,12 @@ def identify_events(
     # Define candidate timesteps to group into events
     idx_valid = ds["N"].to_numpy() > min_drops
     timesteps = ds["time"].to_numpy()[idx_valid]
+    if "sample_interval" in ds:
+        sample_interval = ds["sample_interval"].compute().item()
+        if temporal_resolution_to_seconds(neighbor_time_interval) < sample_interval:
+            msg = "'neighbor_time_interval' must be at least equal to the dataset sample interval ({sample_interval} s)"
+            raise ValueError(msg)
+
     # Define event list
     event_list = group_timesteps_into_event(
         timesteps=timesteps,
@@ -326,29 +330,32 @@ def _map_files_to_blocks(files_start_time, files_end_time, filepaths, block_star
     return results
 
 
-def get_files_partitions(list_partitions, filepaths, sample_interval, accumulation_interval, rolling):  # noqa: ARG001
+def group_files_by_temporal_partitions(
+    temporal_partitions,
+    filepaths,
+    block_starts_offset=0,
+    block_ends_offset=0,
+):
     """
     Provide information about the required files for each event.
 
-    For each event in `list_partitions`, this function identifies the file paths from `filepaths` that
-    overlap with the event period, adjusted by the `accumulation_interval`. The event period is
-    extended backward or forward based on the `rolling` parameter.
+    For each time block in `temporal_partitions`, the function identifies the `filepaths` that
+    overlap such time period. The time blocks of `temporal_partitions` can be adjusted using
+    block_starts_offset and block_ends_offset e.g. for resampling applications.
 
     Parameters
     ----------
-    list_partitions : list of dict
-        List of events, where each event is a dictionary containing at least 'start_time' and 'end_time'
+    temporal_partitions : list of dict
+        List of time blocks, where each time blocks is a dictionary containing at least 'start_time' and 'end_time'
         keys with `numpy.datetime64` values.
     filepaths : list of str
         List of file paths corresponding to data files.
-    sample_interval : numpy.timedelta64 or int
-        The sample interval of the input dataset.
-    accumulation_interval : numpy.timedelta64 or int
-        Time interval to adjust the event period for accumulation. If an integer is provided, it is
-        assumed to be in seconds.
-    rolling : bool
-        If True, adjust the event period backward by `accumulation_interval` (rolling backward).
-        If False, adjust forward (aggregate forward).
+    block_starts_offset: int
+        Optional offset (in seconds) to add to time blocks starts.
+        Provide negative offset to go back in time.
+    block_ends_offset: int
+        Optional offset (in seconds) to add to time blocks ends.
+        Provide negative offset to go back in time.
 
     Returns
     -------
@@ -359,54 +366,54 @@ def get_files_partitions(list_partitions, filepaths, sample_interval, accumulati
         - 'filepaths': List of file paths overlapping with the adjusted event period.
 
     """
-    if len(filepaths) == 0 or len(list_partitions) == 0:
+    if len(filepaths) == 0 or len(temporal_partitions) == 0:
         return []
 
-    # Ensure sample_interval and accumulation_interval is numpy.timedelta64
-    accumulation_interval = ensure_timedelta_seconds(accumulation_interval)
-    sample_interval = ensure_timedelta_seconds(sample_interval)
-
-    # Define offset on event_end_time
-    offset = accumulation_interval if sample_interval != accumulation_interval else ensure_timedelta_seconds(0)
-
     # Retrieve file start_time and end_time
     files_start_time, files_end_time = get_start_end_time_from_filepaths(filepaths)
 
     # Retrieve partitions blocks start and end time arrays
-    block_starts = np.array([p["start_time"] for p in list_partitions]).astype("M8[s]")
-    block_ends = np.array([p["end_time"] for p in list_partitions]).astype("M8[s]")
+    block_starts = np.array([p["start_time"] for p in temporal_partitions]).astype("M8[s]")
+    block_ends = np.array([p["end_time"] for p in temporal_partitions]).astype("M8[s]")
 
-    # Add optional offset for resampling
-    # TODO: expanding partition time should be done only at L1 stage when resampling
-    # In disdrodb, the time reported is time at the start of the accumulation period !
-    # If sensors report time at the end of measurement interval, we might being reporting time
-    #  with an inaccuracy equals to the sensor measurement interval.
-    # We could correct for that at L0C stage already !
-    block_ends = block_ends + offset
+    # Add optional offset to blocks' starts/ends (e.g. for resampling)
+    block_starts = block_starts + block_starts_offset
+    block_ends = block_ends + block_ends_offset
 
     # Map filepaths to corresponding time blocks
     list_event_info = _map_files_to_blocks(files_start_time, files_end_time, filepaths, block_starts, block_ends)
     return list_event_info
 
 
-def get_files_per_time_block(filepaths, freq="day", tolerance_seconds=120):
+def group_files_by_time_block(filepaths, freq="day", tolerance_seconds=120):
     """
-    Organize files by the days they cover based on their start and end times.
+    Organize files by time blocks based on their start and end times.
+
+    If tolerance_seconds is specified, it adds some tolerance to files start and end_time.
+    This means that files starting/ending next to the time blocks boundaries will be included in both
+    time blocks. This can be useful to deal with imprecise time within files.
 
     Parameters
     ----------
     filepaths : list of str
         List of file paths to be processed.
+    freq: str
+        Frequency of the time block. The default frequency is 'day'.
+    tolerance_seconds: int
+        Tolerance in seconds to subtract/add to files start time and end time.
 
     Returns
     -------
-    dict
-        Dictionary where keys are days (as strings) and values are lists of file paths
-        that cover those days.
+    list of dict
+        A list where each element is a dictionary containing:
+        - 'start_time': Adjusted start time of the event (`datetime.datetime64`).
+        - 'end_time': Adjusted end time of the event (`datetime.datetime64`).
+        - 'filepaths': List of file paths overlapping with the adjusted event period.
 
     Notes
     -----
-    This function adds a tolerance of 60 seconds to account for imprecise time logging by the sensors.
+    In the DISDRODB L0C processing chain, a tolerance of 120 seconds is used to account
+    for the possible imprecise/drifting time logged by the sensors before it is corrected.
     """
     # Empty filepaths list return a dictionary
     if len(filepaths) == 0:
@@ -421,13 +428,13 @@ def get_files_per_time_block(filepaths, freq="day", tolerance_seconds=120):
     files_end_time = files_end_time + np.array(tolerance_seconds, dtype="m8[s]")
 
     # Identify candidate blocks
-    list_partitions = identify_time_partitions(
+    temporal_partitions = identify_time_partitions(
         start_times=files_start_time,
         end_times=files_end_time,
         freq=freq,
     )
-    block_starts = np.array([b["start_time"] for b in list_partitions]).astype("M8[s]")
-    block_ends = np.array([b["end_time"] for b in list_partitions]).astype("M8[s]")
+    block_starts = np.array([b["start_time"] for b in temporal_partitions]).astype("M8[s]")
+    block_ends = np.array([b["end_time"] for b in temporal_partitions]).astype("M8[s]")
 
     # Map filepaths to corresponding time blocks
     list_event_info = _map_files_to_blocks(files_start_time, files_end_time, filepaths, block_starts, block_ends)

disdrodb/utils/attrs.py

@@ -31,7 +31,7 @@ def get_attrs_dict():
     """Get attributes dictionary for DISDRODB product variables and coordinates."""
     import disdrodb
 
-    configs_path = os.path.join(disdrodb.__root_path__, "disdrodb", "etc", "configs")
+    configs_path = os.path.join(disdrodb.package_dir, "etc", "configs")
     attrs_dict = read_yaml(os.path.join(configs_path, "attributes.yaml"))
     return attrs_dict
 
@@ -95,6 +95,8 @@ def update_disdrodb_attrs(ds, product: str):
     # ----------------------------------------------
     # Add time_coverage_start and time_coverage_end
     if "time" in ds.dims:
+        ds["time"] = ds["time"].dt.floor("s")  # ensure no sub-second values
+        ds["time"] = ds["time"].astype("datetime64[s]")
         attrs["time_coverage_start"] = str(ds["time"].data[0])
         attrs["time_coverage_end"] = str(ds["time"].data[-1])
 

disdrodb/utils/dask.py

@@ -134,16 +134,16 @@ def execute_tasks_safely(list_tasks, parallel: bool, logs_dir: str):
     """
     from dask.distributed import get_client
 
+    if not parallel:
+        # Non-parallel mode: just return results directly
+        return list_tasks
+
     # Ensure logs_dir exists
     os.makedirs(logs_dir, exist_ok=True)
 
     # Define file name where to log failed dask tasks
     failed_log_path = os.path.join(logs_dir, "FAILED_DASK_TASKS.log")
 
-    if not parallel:
-        # Non-parallel mode: just return results directly
-        return list_tasks
-
     # Ensure we have a Dask client
     try:
         client = get_client()

disdrodb/utils/dict.py

@@ -0,0 +1,33 @@
+# -----------------------------------------------------------------------------.
+# 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/>.
+
+# -----------------------------------------------------------------------------.
+"""This module contains functions for manipulating dictionaries."""
+
+
+def extract_product_kwargs(kwargs, product):
+    """Infer product kwargs dictionary."""
+    from disdrodb.api.checks import check_product
+    from disdrodb.constants import PRODUCTS_ARGUMENTS
+
+    check_product(product)
+    product_kwargs_keys = set(PRODUCTS_ARGUMENTS.get(product, []))
+    return extract_dictionary(kwargs, keys=product_kwargs_keys)
+
+
+def extract_dictionary(dictionary, keys):
+    """Extract a subset of keys from the dictionary, removing them from the input dictionary."""
+    return {k: dictionary.pop(k) for k in keys if k in dictionary}

disdrodb/utils/encoding.py

@@ -19,6 +19,7 @@
 """DISDRODB netCDF4 encoding utilities."""
 import os
 
+import numpy as np
 import xarray as xr
 
 from disdrodb.utils.yaml import read_yaml
@@ -30,7 +31,7 @@ def get_encodings_dict():
     """Get encoding dictionary for DISDRODB product variables and coordinates."""
     import disdrodb
 
-    configs_path = os.path.join(disdrodb.__root_path__, "disdrodb", "etc", "configs")
+    configs_path = os.path.join(disdrodb.package_dir, "etc", "configs")
     encodings_dict = read_yaml(os.path.join(configs_path, "encodings.yaml"))
     return encodings_dict
 
@@ -66,6 +67,8 @@ def set_encodings(ds: xr.Dataset, encodings_dict: dict) -> xr.Dataset:
 
     # Set time encoding
     if "time" in ds:
+        ds["time"] = ds["time"].dt.floor("s")  # ensure no sub-second values
+        ds["time"] = ds["time"].astype("datetime64[s]")
         ds["time"].encoding.update(get_time_encoding())
 
     # Set the variable encodings
@@ -140,6 +143,8 @@ def get_time_encoding() -> dict:
         Time encoding.
     """
     encoding = {}
+    encoding["dtype"] = "int64"  # if float trailing sub-seconds values
+    encoding["fillvalue"] = np.iinfo(np.int64).max
     encoding["units"] = EPOCH
     encoding["calendar"] = "proleptic_gregorian"
     return encoding

disdrodb/utils/routines.py

@@ -22,24 +22,28 @@ import shutil
 import tempfile
 
 from disdrodb.api.io import find_files
-from disdrodb.api.path import define_file_folder_path, define_temporal_resolution
+from disdrodb.api.path import define_file_folder_path
 from disdrodb.utils.logger import (
     close_logger,
     create_logger_file,
     log_error,
     log_info,
 )
+from disdrodb.utils.time import get_sampling_information
 
 
-def is_possible_product(accumulation_interval, sample_interval, rolling):
+def is_possible_product(temporal_resolution, sample_interval):
     """Assess if production is possible given the requested accumulation interval and source sample_interval."""
+    # Retrieve accumulation_interval and rolling option
+    accumulation_interval, rolling = get_sampling_information(temporal_resolution)
+
     # Avoid rolling product generation at source sample interval
     if rolling and accumulation_interval == sample_interval:
         return False
     # Avoid product generation if the accumulation_interval is less than the sample interval
     if accumulation_interval < sample_interval:
         return False
-    # Avoid producti generation if accumulation_interval is not multiple of sample_interval
+    # Avoid product generation if accumulation_interval is not multiple of sample_interval
     return accumulation_interval % sample_interval == 0
 
 
@@ -67,11 +71,8 @@ def try_get_required_filepaths(
     # If no files available, print informative message
     except Exception as e:
         temporal_resolution = ""
-        if "sample_interval" in product_kwargs and "rolling" in product_kwargs:
-            temporal_resolution = define_temporal_resolution(
-                seconds=product_kwargs["sample_interval"],
-                rolling=product_kwargs["rolling"],
-            )
+        if "temporal_resolution" in product_kwargs:
+            temporal_resolution = product_kwargs["temporal_resolution"]
         print(str(e))
         msg = (
             f"{product} processing of {data_source} {campaign_name} {station_name} "

disdrodb/utils/time.py

@@ -62,7 +62,7 @@ def seconds_to_temporal_resolution(seconds):
     return temporal_resolution
 
 
-def get_resampling_information(temporal_resolution):
+def get_sampling_information(temporal_resolution):
     """
     Extract resampling information from the temporal_resolution string.
 
@@ -127,7 +127,7 @@ def temporal_resolution_to_seconds(temporal_resolution):
     seconds
         Duration in seconds.
     """
-    seconds, _ = get_resampling_information(temporal_resolution)
+    seconds, _ = get_sampling_information(temporal_resolution)
     return seconds
 
 
@@ -235,6 +235,8 @@ def regularize_dataset(
     time_dim: str = "time",
     method: Optional[str] = None,
     fill_value=None,
+    start_time=None,
+    end_time=None,
 ):
     """Regularize a dataset across time dimension with uniform resolution.
 
@@ -265,7 +267,13 @@ def regularize_dataset(
     """
     attrs = xr_obj.attrs.copy()
     xr_obj = _check_time_sorted(xr_obj, time_dim=time_dim)
-    start_time, end_time = get_dataset_start_end_time(xr_obj, time_dim=time_dim)
+
+    # Define start time and end_time
+    start, end = get_dataset_start_end_time(xr_obj, time_dim=time_dim)
+    if start_time is None:
+        start_time = start
+    if end_time is None:
+        end_time = end
 
     # Define new time index
     new_time_index = pd.date_range(

disdrodb/viz/__init__.py

@@ -15,16 +15,3 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """DISDRODB Visualization Module."""
-from disdrodb.viz.plots import (
-    compute_dense_lines,
-    max_blend_images,
-    plot_nd,
-    to_rgba,
-)
-
-__all__ = [
-    "compute_dense_lines",
-    "max_blend_images",
-    "plot_nd",
-    "to_rgba",
-]

disdrodb/viz/plots.py

@@ -20,6 +20,29 @@ import numpy as np
 import psutil
 import xarray as xr
 from matplotlib.colors import LogNorm, Normalize
+from matplotlib.gridspec import GridSpec
+
+from disdrodb.constants import DIAMETER_DIMENSION, VELOCITY_DIMENSION
+from disdrodb.l2.empirical_dsd import get_drop_average_velocity
+
+####-------------------------------------------------------------------------------------------------------
+#### N(D) visualizations
+
+
+def _single_plot_nd_distribution(drop_number_concentration, diameter, diameter_bin_width):
+    fig, ax = plt.subplots(1, 1)
+    ax.bar(
+        diameter,
+        drop_number_concentration,
+        width=diameter_bin_width,
+        edgecolor="darkgray",
+        color="lightgray",
+        label="Data",
+    )
+    ax.set_title("Drop number concentration (N(D))")
+    ax.set_xlabel("Drop diameter (mm)")
+    ax.set_ylabel("N(D) [m-3 mm-1]")
+    return ax
 
 
 def plot_nd(ds, var="drop_number_concentration", cmap=None, norm=None):
@@ -27,8 +50,15 @@ def plot_nd(ds, var="drop_number_concentration", cmap=None, norm=None):
     # Check inputs
     if var not in ds:
         raise ValueError(f"{var} is not a xarray Dataset variable!")
+
     # Check only time and diameter dimensions are specified
-    # TODO: DIAMETER_DIMENSION, "time"
+    if "time" not in ds.dims:
+        ax = _single_plot_nd_distribution(
+            drop_number_concentration=ds[var],
+            diameter=ds["diameter_bin_center"],
+            diameter_bin_width=ds["diameter_bin_width"],
+        )
+        return ax
 
     # Select N(D)
     ds_var = ds[[var]].compute()
@@ -53,6 +83,206 @@ def plot_nd(ds, var="drop_number_concentration", cmap=None, norm=None):
     return p
 
 
+####-------------------------------------------------------------------------------------------------------
+#### Spectra visualizations
+
+
+def _check_has_diameter_and_velocity_dims(da):
+    if DIAMETER_DIMENSION not in da.dims or VELOCITY_DIMENSION not in da.dims:
+        raise ValueError(f"The DataArray must have both '{DIAMETER_DIMENSION}' and '{VELOCITY_DIMENSION}' dimensions.")
+    return da
+
+
+def _get_spectrum_variable(xr_obj, variable):
+    if not isinstance(xr_obj, (xr.Dataset, xr.DataArray)):
+        raise TypeError("Expecting xarray object as input.")
+    if isinstance(xr_obj, xr.Dataset):
+        if variable not in xr_obj:
+            raise ValueError(f"The dataset do not include {variable=}.")
+        xr_obj = xr_obj[variable]
+    xr_obj = _check_has_diameter_and_velocity_dims(xr_obj)
+    return xr_obj
+
+
+def plot_spectrum(
+    xr_obj,
+    variable="raw_drop_number",
+    ax=None,
+    cmap=None,
+    norm=None,
+    extend="max",
+    add_colorbar=True,
+    cbar_kwargs=None,
+    title="Drop Spectrum",
+    **plot_kwargs,
+):
+    """Plot the spectrum.
+
+    Parameters
+    ----------
+    xr_obj : xarray.Dataset or xarray.DataArray
+        Input xarray object. If Dataset, the variable to plot must be specified.
+        If DataArray, it must have both diameter and velocity dimensions.
+    variable : str
+        Name of the variable to plot if xr_obj is a Dataset.
+    ax : matplotlib.axes.Axes, optional
+        Axes to plot on. If None, uses current axes or creates a new one.
+    cmap : Colormap, optional
+        Colormap to use. If None, uses 'Spectral_r' with 'under' set to 'none'.
+    norm : matplotlib.colors.Normalize, optional
+        Normalization for colormap. If None, uses LogNorm with vmin=1.
+    extend : {'neither', 'both', 'min', 'max'}, optional
+        Whether to draw arrows on the colorbar to indicate out-of-range values.
+        Default is 'max'.
+    add_colorbar : bool, optional
+        Whether to add a colorbar. Default is True.
+    cbar_kwargs : dict, optional
+        Additional keyword arguments for colorbar. If None, uses {'label': 'Number of particles '}.
+    title : str, optional
+        Title of the plot. Default is 'Drop Spectrum'.
+    **plot_kwargs : dict
+        Additional keyword arguments passed to xarray's plot.pcolormesh method.
+
+    Notes
+    -----
+    - If the input DataArray has a time dimension, it is summed over time before plotting
+        unless FacetGrid options (e.g., col, row) are specified in plot_kwargs.
+    - If FacetGrid options are used, the plot will create a grid of subplots for each time slice.
+      To create a FacetGrid plot, use:
+
+      ds.isel(time=slice(0, 9)).disdrodb.plot_spectrum(col="time", col_wrap=3)
+
+    """
+    # Retrieve spectrum
+    drop_number = _get_spectrum_variable(xr_obj, variable)
+
+    # Check if FacetGrid
+    is_facetgrid = "col" in plot_kwargs or "row" in plot_kwargs
+
+    # Sum over time dimension if still present
+    # - Unless FacetGrid options in plot_kwargs
+    if "time" in drop_number.dims and not is_facetgrid:
+        drop_number = drop_number.sum(dim="time")
+
+    # Define default cbar_kwargs if not specified
+    if cbar_kwargs is None:
+        cbar_kwargs = {"label": "Number of particles"}
+
+    # Define cmap and norm
+    if cmap is None:
+        cmap = plt.get_cmap("Spectral_r").copy()
+        cmap.set_under("none")
+
+    if norm is None:
+        norm = LogNorm(vmin=1, vmax=None) if drop_number.sum() > 0 else None
+
+    # Remove cbar_kwargs if add_colorbar=False
+    if not add_colorbar:
+        cbar_kwargs = None
+
+    # Plot
+    p = drop_number.plot.pcolormesh(
+        ax=ax,
+        x=DIAMETER_DIMENSION,
+        y=VELOCITY_DIMENSION,
+        cmap=cmap,
+        extend=extend,
+        norm=norm,
+        add_colorbar=add_colorbar,
+        cbar_kwargs=cbar_kwargs,
+        **plot_kwargs,
+    )
+    if not is_facetgrid:
+        p.axes.set_xlabel("Diamenter [mm]")
+        p.axes.set_ylabel("Fall velocity [m/s]")
+        p.axes.set_title(title)
+    else:
+        p.set_axis_labels("Diameter [mm]", "Fall velocity [m/s]")
+
+    return p
+
+
+def plot_raw_and_filtered_spectra(
+    ds,
+    cmap=None,
+    norm=None,
+    extend="max",
+    add_theoretical_average_velocity=True,
+    add_measured_average_velocity=True,
+    figsize=(8, 4),
+    dpi=300,
+):
+    """Plot raw and filtered drop spectrum."""
+    # Retrieve spectrum arrays
+    drop_number = _get_spectrum_variable(ds, variable="drop_number")
+    if "time" in drop_number.dims:
+        drop_number = drop_number.sum(dim="time")
+    drop_number = drop_number.compute()
+
+    raw_drop_number = _get_spectrum_variable(ds, variable="raw_drop_number")
+    if "time" in raw_drop_number.dims:
+        raw_drop_number = raw_drop_number.sum(dim="time")
+    raw_drop_number = raw_drop_number.compute()
+
+    # Compute theoretical and measured average velocity if asked
+    if add_theoretical_average_velocity:
+        theoretical_average_velocity = ds["fall_velocity"]
+        if "time" in theoretical_average_velocity.dims:
+            theoretical_average_velocity = theoretical_average_velocity.mean(dim="time")
+    if add_measured_average_velocity:
+        measured_average_velocity = get_drop_average_velocity(drop_number)
+
+    # Define norm if not specified
+    if norm is None:
+        norm = LogNorm(1, raw_drop_number.max())
+
+    # Initialize figure
+    fig = plt.figure(figsize=figsize, dpi=dpi)
+    gs = GridSpec(1, 2, width_ratios=[1, 1.15], wspace=0.05)  # More space for ax2
+    ax1 = fig.add_subplot(gs[0])
+    ax2 = fig.add_subplot(gs[1])
+
+    # Plot raw_drop_number
+    plot_spectrum(raw_drop_number, ax=ax1, cmap=cmap, norm=norm, extend=extend, add_colorbar=False, title="")
+
+    # Add velocities if asked
+    if add_theoretical_average_velocity:
+        theoretical_average_velocity.plot(ax=ax1, c="k", linestyle="dashed")
+    if add_measured_average_velocity:
+        measured_average_velocity.plot(ax=ax1, c="k", linestyle="dotted")
+
+    # Improve plot appearance
+    ax1.set_xlabel("Diamenter [mm]")
+    ax1.set_ylabel("Fall velocity [m/s]")
+    ax1.set_title("Raw Spectrum")
+
+    # Plot drop_number
+    plot_spectrum(drop_number, ax=ax2, cmap=cmap, norm=norm, extend=extend, add_colorbar=True, title="")
+
+    # Add velocities if asked
+    if add_theoretical_average_velocity:
+        theoretical_average_velocity.plot(ax=ax2, c="k", linestyle="dashed", label="Theoretical velocity")
+    if add_measured_average_velocity:
+        measured_average_velocity.plot(ax=ax2, c="k", linestyle="dotted", label="Measured average velocity")
+
+    # Improve plot appearance
+    ax2.set_yticks([])
+    ax2.set_yticklabels([])
+    ax2.set_xlabel("Diamenter [mm]")
+    ax2.set_ylabel("")
+    ax2.set_title("Filtered Spectrum")
+
+    # Add legend
+    if add_theoretical_average_velocity or add_measured_average_velocity:
+        ax2.legend(loc="lower right", frameon=False)
+
+    return fig
+
+
+####-------------------------------------------------------------------------------------------------------
+#### DenseLines
+
+
 def normalize_array(arr, method="max"):
     """Normalize a NumPy array according to the chosen method.
 

{disdrodb-0.1.4.dist-info → disdrodb-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: disdrodb
-Version: 0.1.4
+Version: 0.2.0
 Summary: disdrodb provides tools to download, standardize, share and analyze global disdrometer data.
 Author: Gionata Ghiggi
 Project-URL: homepage, https://github.com/ltelab/disdrodb
@@ -33,6 +33,7 @@ Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: dask[distributed]
 Requires-Dist: xarray
+Requires-Dist: bottleneck
 Requires-Dist: matplotlib
 Provides-Extra: dev
 Requires-Dist: jupyter; extra == "dev"