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

disdrodb/psd/fitting.py

@@ -23,7 +23,7 @@ from scipy.optimize import minimize
 from scipy.special import gamma, gammaln  # Regularized lower incomplete gamma function
 
 from disdrodb.constants import DIAMETER_DIMENSION
-from disdrodb.l1.fall_velocity import get_dataset_fall_velocity
+from disdrodb.l1.fall_velocity import get_raindrop_fall_velocity_from_ds
 from disdrodb.l2.empirical_dsd import (
     get_median_volume_drop_diameter,
     get_moment,
@@ -607,7 +607,7 @@ def estimate_gamma_parameters(
 
     """
     # Define initial guess for parameters
-    a = mu + 1  # (mu = a-1, a = mu+1)
+    a = mu + 1  # (mu = a-1, a = mu+1) (a > 0 --> mu=-1)
     scale = 1 / Lambda
     initial_params = [a, scale]
 
@@ -1208,13 +1208,13 @@ def apply_gamma_gs(
 ):
     """Estimate GammaPSD model parameters using Grid Search."""
     # Define parameters bounds
-    mu_bounds = (0.01, 20)
-    lambda_bounds = (0.01, 60)
+    mu_bounds = (-1, 40)
+    lambda_bounds = (0, 60)
 
     # Define initial set of parameters
-    mu_step = 0.5
+    mu_step = 0.25
     lambda_step = 0.5
-    mu_values = np.arange(0.01, 20, step=mu_step)
+    mu_values = np.arange(0, 40, step=mu_step)
     lambda_values = np.arange(0, 60, step=lambda_step)
 
     # First round of GS
@@ -1304,15 +1304,17 @@ def apply_lognormal_gs(
     """Estimate LognormalPSD model parameters using Grid Search."""
     # Define parameters bounds
     sigma_bounds = (0, np.inf)  # > 0
-    scale_bounds = (0.1, np.inf)  # > 0
+    scale_bounds = (0, np.inf)  # > 0
     # mu_bounds = (- np.inf, np.inf) # mu = np.log(scale)
 
     # Define initial set of parameters
+    # --> Typically sigma between 0 and 3
+    # --> Typically mu between -2 and 2
     scale_step = 0.2
     sigma_step = 0.2
-    scale_values = np.arange(0.1, 20, step=scale_step)
-    mu_values = np.log(scale_values)  # TODO: define realistic values
-    sigma_values = np.arange(0, 20, step=sigma_step)  # TODO: define realistic values
+    scale_values = np.arange(scale_step, 20, step=scale_step)
+    mu_values = np.log(scale_values)
+    sigma_values = np.arange(0, 3, step=sigma_step)
 
     # First round of GS
     Nt, mu, sigma = _apply_lognormal_gs(
@@ -1333,7 +1335,8 @@ def apply_lognormal_gs(
     # Second round of GS
     sigma_values = define_param_range(sigma, sigma_step, bounds=sigma_bounds)
     scale_values = define_param_range(np.exp(mu), scale_step, bounds=scale_bounds)
-    mu_values = np.log(scale_values)
+    with suppress_warnings():
+        mu_values = np.log(scale_values)
     Nt, mu, sigma = _apply_lognormal_gs(
         mu_values=mu_values,
         sigma_values=sigma_values,
@@ -1365,7 +1368,7 @@ def apply_normalized_gamma_gs(
 ):
     """Estimate NormalizedGammaPSD model parameters using Grid Search."""
     # Define set of mu values
-    mu_arr = np.arange(0.01, 20, step=0.01)
+    mu_arr = np.arange(-4, 30, step=0.01)
 
     # Perform grid search
     with suppress_warnings():
@@ -2353,7 +2356,7 @@ def get_gs_parameters(ds, psd_model, target="ND", transformation="log", error_or
 
     # Check fall velocity is available if target R
     if "fall_velocity" not in ds:
-        ds["fall_velocity"] = get_dataset_fall_velocity(ds)
+        ds["fall_velocity"] = get_raindrop_fall_velocity_from_ds(ds)
 
     # Retrieve estimation function
     func = OPTIMIZATION_ROUTINES_DICT["GS"][psd_model]

disdrodb/routines/l2.py

@@ -72,7 +72,7 @@ from disdrodb.utils.routines import (
 )
 from disdrodb.utils.time import (
     ensure_sample_interval_in_seconds,
-    get_resampling_information,
+    get_sampling_information,
 )
 from disdrodb.utils.writer import write_product
 
@@ -124,7 +124,7 @@ class ProcessingOptions:
             product_options = dict_product_options[temporal_resolution].copy()
 
             # Retrieve accumulation_interval and rolling option
-            accumulation_interval, rolling = get_resampling_information(temporal_resolution)
+            accumulation_interval, rolling = get_sampling_information(temporal_resolution)
 
             # Extract processing options
             archive_options = product_options.pop("archive_options")
@@ -492,7 +492,7 @@ def run_l2e_station(
         product_options = l2e_processing_options.get_product_options(temporal_resolution)
 
         # Retrieve accumulation_interval and rolling option
-        accumulation_interval, rolling = get_resampling_information(temporal_resolution)
+        accumulation_interval, rolling = get_sampling_information(temporal_resolution)
 
         # Precompute required scattering tables
         if product_options["radar_enabled"]:
@@ -655,7 +655,10 @@ def _generate_l2m(
 
         # Define variables to load
         optimization_kwargs = l2m_options["optimization_kwargs"]
-        if "init_method" in optimization_kwargs:
+        if "init_method" in optimization_kwargs and optimization_kwargs["init_method"] is None:
+            optimization_kwargs["init_method"] = "None"
+
+        if optimization_kwargs.get("init_method", "None") != "None":
             init_method = optimization_kwargs["init_method"]
             moments = [f"M{order}" for order in init_method.replace("M", "")] + ["M1"]
         else:
@@ -839,7 +842,7 @@ def run_l2m_station(
     for temporal_resolution in temporal_resolutions:
 
         # Retrieve accumulation_interval and rolling option
-        accumulation_interval, rolling = get_resampling_information(temporal_resolution)
+        accumulation_interval, rolling = get_sampling_information(temporal_resolution)
 
         # ------------------------------------------------------------------.
         # Avoid generation of rolling products for source sample interval !
@@ -898,6 +901,7 @@ def run_l2m_station(
         # -----------------------------------------------------------------.
         # Loop over distributions to fit
         # model_name = "GAMMA_ML"
+        # model_name = "LOGNORMAL_GS_ND_MAE"
         # model_options =  l2m_options["models"][model_name]
         # Retrieve list of models to fit
         models = global_product_options.pop("models")
@@ -924,23 +928,31 @@ def run_l2m_station(
 
             # -------------------------------------------------------------.
             # Create product directory
-            data_dir = create_product_directory(
-                # DISDRODB root directories
-                data_archive_dir=data_archive_dir,
-                metadata_archive_dir=metadata_archive_dir,
-                # Station arguments
-                data_source=data_source,
-                campaign_name=campaign_name,
-                station_name=station_name,
-                # Processing options
-                product=product,
-                force=force,
-                # Option for L2E
-                sample_interval=accumulation_interval,
-                rolling=rolling,
-                # Option for L2M
-                model_name=model_name,
-            )
+            try:
+                data_dir = create_product_directory(
+                    # DISDRODB root directories
+                    data_archive_dir=data_archive_dir,
+                    metadata_archive_dir=metadata_archive_dir,
+                    # Station arguments
+                    data_source=data_source,
+                    campaign_name=campaign_name,
+                    station_name=station_name,
+                    # Processing options
+                    product=product,
+                    force=force,
+                    # Option for L2E
+                    sample_interval=accumulation_interval,
+                    rolling=rolling,
+                    # Option for L2M
+                    model_name=model_name,
+                )
+            except Exception:
+                msg = (
+                    f"Production of L2M_{model_name} for sample interval {accumulation_interval} s has been "
+                    + "skipped because the product already exists and force=False."
+                )
+                log_info(logger=logger, msg=msg, verbose=verbose)
+                continue
 
             # Define logs directory
             logs_dir = create_logs_directory(
@@ -1005,7 +1017,7 @@ def run_l2m_station(
                 data_archive_dir=data_archive_dir,
                 # Product options
                 model_name=model_name,
-                sample_interval=sample_interval,
+                sample_interval=accumulation_interval,
                 rolling=rolling,
                 # Logs list
                 list_logs=list_logs,

disdrodb/routines/wrappers.py

@@ -643,6 +643,7 @@ def create_summary_station(
     campaign_name,
     station_name,
     parallel=False,
+    temporal_resolution="1MIN",
     data_archive_dir=None,
 ):
     """Create summary figures and tables for a DISDRODB station."""
@@ -658,6 +659,8 @@ def create_summary_station(
             str(data_archive_dir),
             "--parallel",
             str(parallel),
+            "--temporal_resolution",
+            str(temporal_resolution),
         ],
     )
     # Execute command
@@ -1440,6 +1443,7 @@ def create_summary(
     campaign_names=None,
     station_names=None,
     parallel=False,
+    temporal_resolution="1MIN",
     data_archive_dir=None,
     metadata_archive_dir=None,
 ):
@@ -1493,6 +1497,7 @@ def create_summary(
             station_name=station_name,
             # Processing option
             parallel=parallel,
+            temporal_resolution=temporal_resolution,
         )
     print("Creation of station summaries has terminated.")
 

disdrodb/scattering/axis_ratio.py

@@ -20,90 +20,6 @@ import numpy as np
 import xarray as xr
 
 
-def available_axis_ratio_models():
-    """Return a list of the available drop axis ratio models."""
-    return list(AXIS_RATIO_MODELS)
-
-
-def get_axis_ratio_model(model):
-    """Return the specified drop axis ratio model.
-
-    Parameters
-    ----------
-    model : str
-        The model to use for calculating the axis ratio. Available models are:
-        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
-        'Pruppacher1970', 'Beard1987', 'Andsager1999'.
-
-    Returns
-    -------
-    callable
-        A function which compute the vertical-to-horizontal axis ratio given a
-        particle diameter in mm.
-
-    Notes
-    -----
-    This function serves as a wrapper to various axis ratio models for raindrops.
-    It returns the appropriate model based on the `model` parameter.
-
-    Please note that the axis ratio function to be provided to pyTmatrix expects to
-    return a horizontal-to-vertical axis ratio !
-
-    """
-    model = check_axis_ratio_model(model)
-    return AXIS_RATIO_MODELS[model]
-
-
-def check_axis_ratio_model(model):
-    """Check validity of the specified drop axis ratio model."""
-    available_models = available_axis_ratio_models()
-    if model not in available_models:
-        raise ValueError(f"{model} is an invalid axis-ratio model. Valid models: {available_models}.")
-    return model
-
-
-def get_axis_ratio(diameter, model):
-    """
-    Compute the axis ratio of raindrops using the specified model.
-
-    Parameters
-    ----------
-    diameter : array-like
-        Raindrops diameter in mm.
-    model : str
-        The axis ratio model to use for calculating the axis ratio. Available models are:
-        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
-        'Pruppacher1970', 'Beard1987', 'Andsager1999'.
-
-    Returns
-    -------
-    axis_ratio : array-like
-        The vertical-to-horizontal drop axis ratio corresponding to the input diameters.
-        Values of 1 indicate spherical particles, while values <1 indicate oblate particles.
-        Values >1 means prolate particles.
-
-    Notes
-    -----
-    This function serves as a wrapper to various axis ratio models for raindrops.
-    It selects and applies the appropriate model based on the `model` parameter.
-
-    Examples
-    --------
-    >>> diameter = np.array([0.5, 1.0, 2.0, 3.0])
-    >>> axis_ratio = get_axis_ratio(diameter, model="Brandes2002")
-
-    """
-    # Retrieve axis ratio function
-    axis_ratio_func = get_axis_ratio_model(model)
-
-    # Retrieve axis ratio
-    axis_ratio = axis_ratio_func(diameter)
-
-    # Clip values between 0 and 1
-    axis_ratio = np.clip(axis_ratio, 0, 1)
-    return axis_ratio
-
-
 def get_axis_ratio_andsager_1999(diameter):
     """
     Compute the axis ratio of raindrops using the Andsager et al. (1999) model.
@@ -366,3 +282,93 @@ AXIS_RATIO_MODELS = {
     "Beard1987": get_axis_ratio_beard_1987,
     "Andsager1999": get_axis_ratio_andsager_1999,
 }
+
+
+def available_axis_ratio_models():
+    """Return a list of the available drop axis ratio models."""
+    return list(AXIS_RATIO_MODELS)
+
+
+def check_axis_ratio_model(model):
+    """Check validity of the specified drop axis ratio model."""
+    available_models = available_axis_ratio_models()
+    if model not in available_models:
+        raise ValueError(f"{model} is an invalid axis-ratio model. Valid models: {available_models}.")
+    return model
+
+
+def get_axis_ratio_model(model):
+    """Return the specified drop axis ratio model.
+
+    Parameters
+    ----------
+    model : str
+        The model to use for calculating the axis ratio. Available models are:
+        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
+        'Pruppacher1970', 'Beard1987', 'Andsager1999'.
+
+    Returns
+    -------
+    callable
+        A function which compute the vertical-to-horizontal axis ratio given a
+        particle diameter in mm.
+
+    Notes
+    -----
+    This function serves as a wrapper to various axis ratio models for raindrops.
+    It returns the appropriate model based on the `model` parameter.
+
+    Please note that the axis ratio function to be provided to pyTmatrix expects to
+    return a horizontal-to-vertical axis ratio !
+
+    """
+    model = check_axis_ratio_model(model)
+    return AXIS_RATIO_MODELS[model]
+
+
+def get_axis_ratio(diameter, model):
+    """
+    Compute the axis ratio of raindrops using the specified model.
+
+    Parameters
+    ----------
+    diameter : array-like
+        Raindrops diameter in mm.
+    model : str
+        The axis ratio model to use for calculating the axis ratio. Available models are:
+        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
+        'Pruppacher1970', 'Beard1987', 'Andsager1999'.
+
+    Returns
+    -------
+    axis_ratio : array-like
+        The vertical-to-horizontal drop axis ratio corresponding to the input diameters.
+        Values of 1 indicate spherical particles, while values <1 indicate oblate particles.
+        Values >1 means prolate particles.
+
+    Notes
+    -----
+    This function serves as a wrapper to various axis ratio models for raindrops.
+    It selects and applies the appropriate model based on the `model` parameter.
+
+    Examples
+    --------
+    >>> diameter = np.array([0.5, 1.0, 2.0, 3.0])
+    >>> axis_ratio = get_axis_ratio(diameter, model="Brandes2002")
+
+    """
+    # Retrieve axis ratio function
+    axis_ratio_func = get_axis_ratio_model(model)
+
+    # Retrieve axis ratio
+    axis_ratio = axis_ratio_func(diameter)
+
+    # Clip values between 0 and 1
+    axis_ratio = np.clip(axis_ratio, 0, 1)
+
+    # Add attributes
+    if isinstance(axis_ratio, xr.DataArray):
+        axis_ratio.name = "axis_ratio"
+        axis_ratio.attrs["units"] = ""
+        axis_ratio.attrs["model"] = model
+    return axis_ratio

disdrodb/scattering/permittivity.py

@@ -147,6 +147,12 @@ def get_refractive_index(temperature, frequency, permittivity_model):
 
     # Retrieve refractive_index
     refractive_index = func(temperature=temperature, frequency=frequency)
+
+    # Add attributes
+    if isinstance(refractive_index, xr.DataArray):
+        refractive_index.name = "refractive_index"
+        refractive_index.attrs["units"] = ""
+        refractive_index.attrs["model"] = permittivity_model
     return refractive_index
 
 

disdrodb/summary/routines.py

@@ -43,6 +43,7 @@ from disdrodb.utils.manipulations import (
     resample_drop_number_concentration,
     unstack_radar_variables,
 )
+from disdrodb.utils.time import get_sampling_information
 from disdrodb.utils.warnings import suppress_warnings
 from disdrodb.utils.yaml import write_yaml
 from disdrodb.viz import compute_dense_lines, max_blend_images, to_rgba
@@ -247,8 +248,9 @@ def create_table_dsd_summary(df):
     df_stats["SKEWNESS"] = df_subset.skew()
     df_stats["KURTOSIS"] = df_subset.kurt()
 
-    # Round statistics
-    df_stats = df_stats.astype(float).round(2)
+    # Round float columns to nearest integer, leave ints unchanged
+    float_cols = df_stats.select_dtypes(include=["float"]).columns
+    df_stats[float_cols] = df_stats[float_cols].astype(float).round(decimals=2)
     return df_stats
 
 
@@ -327,15 +329,19 @@ def create_table_events_summary(df):
         events_stats.append(event_stats)
 
     df_events = pd.DataFrame.from_records(events_stats)
+
+    # Round float columns to nearest integer, leave ints unchanged
+    float_cols = df_events.select_dtypes(include=["float"]).columns
+    df_events[float_cols] = df_events[float_cols].astype(float).round(decimals=2)
     return df_events
 
 
 def prepare_latex_table_dsd_summary(df):
     """Prepare a DataFrame with DSD statistics for LaTeX table output."""
     df = df.copy()
-    # Round float columns to nearest integer, leave ints unchanged
-    float_cols = df.select_dtypes(include=["float"]).columns
-    df[float_cols] = df[float_cols].astype(float).round(decimals=2).astype(str)
+    # Cast numeric columns to string
+    numeric_cols = df.select_dtypes(include=["float", "int"]).columns
+    df[numeric_cols] = df[numeric_cols].astype(str)
     # Rename
     rename_dict = {
         "W": r"$W\,[\mathrm{g}\,\mathrm{m}^{-3}]$",  # [g/m3]
@@ -360,9 +366,9 @@ def prepare_latex_table_events_summary(df):
     # Round datetime to minutes
     df["start_time"] = df["start_time"].dt.strftime("%Y-%m-%d %H:%M")
     df["end_time"] = df["end_time"].dt.strftime("%Y-%m-%d %H:%M")
-    # Round float columns to nearest integer, leave ints unchanged
-    float_cols = df.select_dtypes(include=["float"]).columns
-    df[float_cols] = df[float_cols].astype(float).round(decimals=2).astype(str)
+    # Cast numeric columns to string
+    numeric_cols = df.select_dtypes(include=["float", "int"]).columns
+    df[numeric_cols] = df[numeric_cols].astype(str)
     # Rename
     rename_dict = {
         "start_time": r"Start",
@@ -688,6 +694,13 @@ def plot_raw_and_filtered_spectrums(
     cmap = plt.get_cmap("Spectral_r").copy()
     cmap.set_under("none")
 
+    if "time" in drop_number.dims:
+        drop_number = drop_number.sum(dim="time")
+    if "time" in raw_drop_number.dims:
+        raw_drop_number = raw_drop_number.sum(dim="time")
+    if "time" in theoretical_average_velocity.dims:
+        theoretical_average_velocity = theoretical_average_velocity.mean(dim="time")
+
     if norm is None:
         norm = LogNorm(1, None)
 
@@ -3729,8 +3742,9 @@ def define_filename(prefix, extension, data_source, campaign_name, station_name)
 
 def create_l2_dataframe(ds):
     """Create pandas Dataframe for L2 analysis."""
+    dims_to_drop = set(ds.dims).intersection({DIAMETER_DIMENSION, VELOCITY_DIMENSION})
     # - Drop array variables and convert to pandas
-    df = ds.drop_dims([DIAMETER_DIMENSION, VELOCITY_DIMENSION]).to_pandas()
+    df = ds.drop_dims(dims_to_drop).to_pandas()
     # - Drop coordinates
     coords_to_drop = ["velocity_method", "sample_interval", *RADAR_OPTIONS]
     df = df.drop(columns=coords_to_drop, errors="ignore")
@@ -3759,7 +3773,11 @@ def prepare_summary_dataset(ds, velocity_method="fall_velocity", source="drop_nu
 
     # Select only timesteps with R > 0
     # - We save R with 2 decimals accuracy ... so 0.01 is the smallest value
-    rainy_timesteps = np.logical_and(ds["Rm"].compute() >= 0.01, ds["R"].compute() >= 0.01)
+    if "Rm" in ds:  # in L2E
+        rainy_timesteps = np.logical_and(ds["Rm"].compute() >= 0.01, ds["R"].compute() >= 0.01)
+    else:  # L2M without Rm
+        rainy_timesteps = ds["R"].compute() >= 0.01
+
     ds = ds.isel(time=rainy_timesteps)
     return ds
 
@@ -3776,10 +3794,13 @@ def generate_station_summary(ds, summary_dir_path, data_source, campaign_name, s
     # Ensure all data are in memory
     ds = ds.compute()
 
+    # Keep only timesteps with at least 3 Nbins to remove noise
+    valid_idx = np.where(ds["Nbins"] >= 3)[0]
+    ds = ds.isel(time=valid_idx)
+
     ####---------------------------------------------------------------------.
     #### Create drop spectrum figures and statistics
     # Compute sum of raw and filtered spectrum over time
-
     raw_drop_number = ds["raw_drop_number"].sum(dim="time")
     drop_number = ds["drop_number"].sum(dim="time")
 
@@ -4153,6 +4174,7 @@ def create_station_summary(
     station_name,
     parallel=False,
     data_archive_dir=None,
+    temporal_resolution="1MIN",
 ):
     """Create summary figures and tables for a DISDRODB station."""
     # Print processing info
@@ -4169,6 +4191,10 @@ def create_station_summary(
     )
     os.makedirs(summary_dir_path, exist_ok=True)
 
+    # Define product_kwargs
+    sample_interval, rolling = get_sampling_information(temporal_resolution)
+    product_kwargs = {"rolling": rolling, "sample_interval": sample_interval}
+
     # Load L2E 1MIN dataset
     ds = disdrodb.open_dataset(
         data_archive_dir=data_archive_dir,
@@ -4176,7 +4202,7 @@ def create_station_summary(
         campaign_name=campaign_name,
         station_name=station_name,
         product="L2E",
-        product_kwargs={"rolling": False, "sample_interval": 60},
+        product_kwargs=product_kwargs,
         parallel=parallel,
         chunks=-1,
         compute=True,

disdrodb/utils/attrs.py

@@ -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/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
@@ -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/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
 
 

disdrodb/viz/plots.py

@@ -22,13 +22,36 @@ import xarray as xr
 from matplotlib.colors import LogNorm, Normalize
 
 
+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):
     """Plot drop number concentration N(D) timeseries."""
     # 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()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: disdrodb
-Version: 0.1.4
+Version: 0.1.5
 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"