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

disdrodb/scattering/permittivity.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # temperaturehis program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Implement particle permittivity models."""
+
 import numpy as np
 import xarray as xr
 
@@ -56,7 +57,7 @@ def get_refractive_index_function(permittivity_model):
     ----------
     model : str
         The model to use for calculating the complex refractive index. Available models are:
-        'Liebe1991', 'Liebe1991v2', 'Ellison2005', 'Turner2016', 'Turner2016SLC'.
+        'Liebe1991', 'Liebe1991v2', 'Ellison2007', 'Turner2016', 'Turner2016SLC'.
 
     Returns
     -------
@@ -104,7 +105,7 @@ def get_refractive_index(temperature, frequency, permittivity_model):
         Frequency in GHz.
     permittivity_model : str
         The permittivity model to use for calculating the complex refractive index.
-        Available models are: 'Liebe1991', 'Liebe1991v2', 'Ellison2005', 'Turner2016', 'Turner2016SLC'.
+        Available models are: 'Liebe1991', 'Liebe1991v2', 'Ellison2007', 'Turner2016', 'Turner2016SLC'.
         See available models with ``disdrodb.scattering.available_permittivity_models()``.
 
     Returns
@@ -309,7 +310,7 @@ def get_rain_refractive_index_liebe1991(temperature, frequency):
     return m
 
 
-def get_rain_refractive_index_ellison2005(temperature, frequency):
+def get_rain_refractive_index_ellison2007(temperature, frequency):
     """Compute the complex refractive index according to Ellison (2005) model.
 
     Parameters
@@ -343,8 +344,8 @@ def get_rain_refractive_index_ellison2005(temperature, frequency):
     temperature = ensure_array(temperature)
 
     # Check frequency and temperature within validity range
-    temperature = check_temperature_validity_range(temperature, vmin=0, vmax=100, permittivity_model="Ellison2005")
-    frequency = check_frequency_validity_range(frequency, vmin=0, vmax=1000, permittivity_model="Ellison2005")
+    temperature = check_temperature_validity_range(temperature, vmin=0, vmax=100, permittivity_model="Ellison2007")
+    frequency = check_frequency_validity_range(frequency, vmin=0, vmax=1000, permittivity_model="Ellison2007")
 
     # Conversion of frequency to Hz
     frequency = frequency / 1e-9
@@ -479,7 +480,7 @@ def get_rain_refractive_index_turner2016(frequency, temperature):
 def get_rayleigh_dielectric_factor(m):
     """Compute the Rayleigh dielectric factor |K|**2 from the complex refractive index.
 
-    The magnitude squared of the complex dielectric contrast factor for liquid water,
+    The magnitude squared of the complex dielectric constant factor for liquid water,
     relative to the surrounding medium (typically air).
 
     This factor is used to compute the radar reflectivity.
@@ -505,6 +506,6 @@ def get_rayleigh_dielectric_factor(m):
 REFRACTIVE_INDEX_MODELS = {
     "Liebe1991": get_rain_refractive_index_liebe1991,
     "Liebe1991single": get_rain_refractive_index_liebe1991_single,
-    "Ellison2005": get_rain_refractive_index_ellison2005,
+    "Ellison2007": get_rain_refractive_index_ellison2007,
     "Turner2016": get_rain_refractive_index_turner2016,
 }

disdrodb/scattering/routines.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -26,7 +26,6 @@ import xarray as xr
 
 from disdrodb.configs import get_scattering_table_dir
 from disdrodb.constants import DIAMETER_DIMENSION
-from disdrodb.l1.filters import filter_diameter_bins
 from disdrodb.psd.models import BinnedPSD, create_psd, get_required_parameters
 from disdrodb.scattering.axis_ratio import check_axis_ratio_model, get_axis_ratio_model
 from disdrodb.scattering.permittivity import (
@@ -35,7 +34,7 @@ from disdrodb.scattering.permittivity import (
     get_refractive_index,
 )
 from disdrodb.utils.logger import log_info
-from disdrodb.utils.manipulations import get_diameter_bin_edges
+from disdrodb.utils.manipulations import filter_diameter_bins, get_diameter_bin_edges
 from disdrodb.utils.warnings import suppress_warnings
 
 logger = logging.getLogger(__name__)
@@ -76,20 +75,31 @@ def check_radar_band(radar_band):
     return radar_band
 
 
+def _is_valid_numeric_frequency(frequency):
+    numeric_value = float(frequency)
+    if numeric_value <= 0:
+        raise ValueError(f"Frequency must be positive, got {numeric_value}")
+    return numeric_value
+
+
 def _check_frequency(frequency):
     """Check the validity of the specified frequency."""
     if isinstance(frequency, str):
-        frequency = check_radar_band(frequency)
-        frequency = frequency_dict[frequency]
-        return frequency
-    if not isinstance(frequency, (int, float)):
-        raise TypeError(f"Frequency {frequency} must be a string or a number.")
-    return frequency
+        try:
+            frequency = float(frequency)
+
+        except ValueError:
+            # Not numeric, assume radar band name
+            frequency = check_radar_band(frequency)
+            frequency = frequency_dict[frequency]
+    if isinstance(frequency, (int, float, np.integer, np.floating)):
+        return _is_valid_numeric_frequency(frequency)
+    raise TypeError(f"Frequency {frequency} must be a string or a number.")
 
 
 def ensure_numerical_frequency(frequency):
     """Ensure that the frequencies are numerical values in GHz."""
-    if isinstance(frequency, (str, int, float)):
+    if isinstance(frequency, (str, int, float, np.integer, np.floating)):
         frequency = [frequency]
     frequency = np.array([_check_frequency(f) for f in frequency])
     return frequency.squeeze()
@@ -476,6 +486,11 @@ def compute_radar_variables(scatterer):
 
     To speed up computations, this function should input a scatterer object with
     a preinitialized scattering table.
+
+    Note
+    ----
+    If this function is modified to compute additional radar variables, the global
+    variable RADAR_VARIABLES must be updated accordingly !
     """
     from pytmatrix import radar
 
@@ -495,10 +510,13 @@ def compute_radar_variables(scatterer):
         radar_vars["ZDR"] = 10 * np.log10(radar.Zdr(scatterer))  # dB
         radar_vars["ZDR"] = np.where(np.isfinite(radar_vars["ZDR"]), radar_vars["ZDR"], np.nan)
 
-        radar_vars["LDR"] = 10 * np.log10(radar.ldr(scatterer))  # dBZ
-        radar_vars["LDR"] = np.where(np.isfinite(radar_vars["LDR"]), radar_vars["LDR"], np.nan)
+        radar_vars["LDRH"] = 10 * np.log10(radar.ldr(scatterer, h_pol=True))  # dBZ
+        radar_vars["LDRH"] = np.where(np.isfinite(radar_vars["LDRH"]), radar_vars["LDRH"], np.nan)
+
+        radar_vars["LDRV"] = 10 * np.log10(radar.ldr(scatterer, h_pol=False))  # dBZ
+        radar_vars["LDRV"] = np.where(np.isfinite(radar_vars["LDRV"]), radar_vars["LDRV"], np.nan)
 
-        radar_vars["RHOHV"] = radar.rho_hv(scatterer)  # deg/km
+        radar_vars["RHOHV"] = radar.rho_hv(scatterer)  # [-]
         radar_vars["DELTAHV"] = radar.delta_hv(scatterer) * 180.0 / np.pi  # [deg]
 
         # Set forward scattering for attenuation and phase calculations
@@ -512,7 +530,7 @@ def compute_radar_variables(scatterer):
 
 # Radar variables computed by DISDRODB
 # - Must reflect dictionary order output of compute_radar_variables
-RADAR_VARIABLES = ["DBZH", "DBZV", "ZDR", "LDR", "RHOHV", "DELTAHV", "KDP", "AH", "AV", "ADP"]
+RADAR_VARIABLES = ["DBZH", "DBZV", "ZDR", "LDRH", "LDRV", "RHOHV", "DELTAHV", "KDP", "AH", "AV", "ADP"]
 
 
 def _try_compute_radar_variables(scatterer):
@@ -544,7 +562,7 @@ def _estimate_model_radar_parameters(
     scatterer,
 ):
     # Assign PSD model to the scatterer object
-    parameters = dict(zip(psd_parameters_names, parameters))
+    parameters = dict(zip(psd_parameters_names, parameters, strict=True))
     scatterer.psd = create_psd(psd_model, parameters)
 
     # Get radar variables

disdrodb/summary/__init__.py

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

disdrodb/summary/routines.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Utilities to create summary statistics."""
+
 import gc
 import importlib
 import os
@@ -223,6 +224,11 @@ def create_table_rain_summary(df, temporal_resolution):
     table["n_minutes_Dmax_>7"] = np.sum(df["Dmax"] > 7).item() * accumulation_interval_minutes
     table["n_minutes_Dmax_>8"] = np.sum(df["Dmax"] > 8).item() * accumulation_interval_minutes
     table["n_minutes_Dmax_>9"] = np.sum(df["Dmax"] > 9).item() * accumulation_interval_minutes
+
+    # Convert all minutes columns to integer
+    for key in table:
+        if "minutes" in key:
+            table[key] = int(table[key])
     return table
 
 
@@ -233,7 +239,7 @@ def create_table_dsd_summary(df):
     df["log10(Nt)"] = np.log10(df["Nt"])
 
     # List of variables to summarize
-    variables = ["W", "R", "Z", "D50", "Dm", "sigma_m", "Dmax", "Nw", "log10(Nw)", "Nt", "log10(Nt)"]
+    variables = ["LWC", "R", "Z", "D50", "Dm", "sigma_m", "Dmax", "Nw", "log10(Nw)", "Nt", "log10(Nt)"]
 
     # Define subset dataframe
     df_subset = df[variables]
@@ -356,9 +362,9 @@ def create_table_events_summary(df, temporal_resolution):
             "mean_sigma_m": df_event["sigma_m"].mean(),
             "median_sigma_m": df_event["sigma_m"].median(),
             "max_sigma_m": df_event["sigma_m"].max(),
-            "mean_W": df_event["W"].mean(),
-            "median_W": df_event["W"].median(),
-            "max_W": df_event["W"].max(),
+            "mean_LWC": df_event["LWC"].mean(),
+            "median_LWC": df_event["LWC"].median(),
+            "max_LWC": df_event["LWC"].max(),
             "max_Z": df_event["Z"].max(),
             "mean_Nbins": int(df_event["Nbins"].mean()),
             "max_Nbins": int(df_event["Nbins"].max()),
@@ -371,9 +377,22 @@ def create_table_events_summary(df, temporal_resolution):
 
     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)
+    # Round and cast columns
+    # - Round to 3 decimals
+    df_events["P_total"] = df_events["P_total"].round(decimals=3)
+
+    lwc_columns = [c for c in df_events.columns if "LWC" in c]
+    df_events[lwc_columns] = df_events[lwc_columns].round(decimals=3)
+
+    # - Cast to integer
+    df_events["duration"] = df_events["duration"].astype(int)
+    minutes_columns = [c for c in df_events.columns if "minutes" in c]
+    df_events[minutes_columns] = df_events[minutes_columns].astype(int)
+
+    # - Round to 2 decimals
+    for var in ["Dmax", "Dm", "sigma_m", "R", "Z"]:
+        names = [c for c in df_events.columns if var in c]
+        df_events[names] = df_events[names].round(decimals=2)
     return df_events
 
 
@@ -385,7 +404,7 @@ def prepare_latex_table_dsd_summary(df):
     df[numeric_cols] = df[numeric_cols].astype(str)
     # Rename
     rename_dict = {
-        "W": r"$W\,[\mathrm{g}\,\mathrm{m}^{-3}]$",  # [g/m3]
+        "LWC": r"$LWC\,[\mathrm{g}\,\mathrm{m}^{-3}]$",  # [g/m3]
         "R": r"$R\,[\mathrm{mm}\,\mathrm{h}^{-1}]$",  # [mm/hr]
         "Z": r"$Z\,[\mathrm{dBZ}]$",  # [dBZ]
         "D50": r"$D_{50}\,[\mathrm{mm}]$",  # [mm]
@@ -433,9 +452,9 @@ def prepare_latex_table_events_summary(df):
         "mean_sigma_m": r"$\sigma_{m,\mathrm{mean}}$",
         "median_sigma_m": r"$\sigma_{m,\mathrm{median}}$",
         "max_sigma_m": r"$\sigma_{m,\max}$",
-        "mean_W": r"$W_{\mathrm{mean}}$",
-        "median_W": r"$W_{\mathrm{median}}$",
-        "max_W": r"$W_{\max}$",
+        "mean_LWC": r"$LWC_{\mathrm{mean}}$",
+        "median_LWC": r"$LWC_{\mathrm{median}}$",
+        "max_LWC": r"$LWC_{\max}$",
         "max_Z": r"$Z_{\max}$",
         "mean_Nbins": r"$N_{\mathrm{bins},\mathrm{mean}}$",
         "max_Nbins": r"$N_{\mathrm{bins},\max}$",
@@ -609,7 +628,7 @@ def fit_powerlaw(x, y, xbins, quantile=0.5, min_counts=10, x_in_db=False, use_ra
                 absolute_sigma=True,
                 maxfev=10_000,  # max n iterations
             )
-            (a_std, b_std) = np.sqrt(np.diag(pcov))
+            a_std, b_std = np.sqrt(np.diag(pcov))
             a_std = float(a_std)
             b_std = float(b_std)
 
@@ -918,7 +937,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
         df,
         x="Dm",
         y="Nw",
-        variables=["R", "W", "Nt"],
+        variables=["R", "LWC", "Nt"],
         x_bins=np.arange(0, 8, 0.1),
         y_bins=log_arange(10, 1_000_000, log_step=0.05, base=10),
     )
@@ -927,7 +946,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     ds_Dm_LWC_stats = compute_2d_histogram(
         df,
         x="Dm",
-        y="W",
+        y="LWC",
         variables=["R", "Nw", "Nt"],
         x_bins=np.arange(0, 8, 0.1),
         y_bins=log_arange(0.01, 10, log_step=0.05, base=10),
@@ -938,7 +957,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
         df,
         x="Dm",
         y="R",
-        variables=["Nw", "W", "Nt"],
+        variables=["Nw", "LWC", "Nt"],
         x_bins=np.arange(0, 8, 0.1),
         y_bins=log_arange(0.1, 500, log_step=0.05, base=10),
     )
@@ -948,7 +967,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
         df,
         x="Dm",
         y="Nt",
-        variables=["R", "W", "Nw"],
+        variables=["R", "LWC", "Nw"],
         x_bins=np.arange(0, 8, 0.1),
         y_bins=log_arange(1, 100_000, log_step=0.05, base=10),
     )
@@ -1019,7 +1038,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     axes[1, 0].set_ylim(nw_lim)
 
     #### - LWC
-    im_lwc = ds_Dm_Nw_stats["W_median"].plot.pcolormesh(
+    im_lwc = ds_Dm_Nw_stats["LWC_median"].plot.pcolormesh(
         x="Dm",
         y="Nw",
         cmap=cmap_lwc,
@@ -1067,7 +1086,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     #### - Counts
     ds_Dm_LWC_stats["count"].plot.pcolormesh(
         x="Dm",
-        y="W",
+        y="LWC",
         cmap=cmap_counts,
         norm=norm_counts,
         extend="max",
@@ -1083,7 +1102,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     # - Empty (diagonal where y-axis is W) - handled above in the loop
     ds_Dm_LWC_stats["R_median"].plot.pcolormesh(
         x="Dm",
-        y="W",
+        y="LWC",
         cmap=cmap_r,
         norm=norm_r,
         alpha=0,  # fully transparent
@@ -1099,7 +1118,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     #### - R
     ds_Dm_LWC_stats["R_median"].plot.pcolormesh(
         x="Dm",
-        y="W",
+        y="LWC",
         cmap=cmap_r,
         norm=norm_r,
         extend="both",
@@ -1114,7 +1133,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     #### - Nt
     im_nt = ds_Dm_LWC_stats["Nt_median"].plot.pcolormesh(
         x="Dm",
-        y="W",
+        y="LWC",
         cmap=cmap_nt,
         norm=norm_nt,
         extend="both",
@@ -1144,7 +1163,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
     axes[3, 0].set_ylim(r_lim)
 
     #### - LWC
-    im_lwc = ds_Dm_R_stats["W_median"].plot.pcolormesh(
+    im_lwc = ds_Dm_R_stats["LWC_median"].plot.pcolormesh(
         x="Dm",
         y="R",
         cmap=cmap_lwc,
@@ -1211,7 +1230,7 @@ def plot_dsd_params_relationships(df, add_nt=False, dpi=300):
         axes[4, 0].set_ylim(nt_lim)
 
         #### - LWC
-        ds_Dm_Nt_stats["W_median"].plot.pcolormesh(
+        ds_Dm_Nt_stats["LWC_median"].plot.pcolormesh(
             x="Dm",
             y="Nt",
             cmap=cmap_lwc,
@@ -1336,7 +1355,7 @@ def plot_dsd_params_density(df, log_dm=False, lwc=True, log_normalize=False, fig
     norm = Normalize(0, 1)  # Normalized data goes from 0 to 1
 
     # Define the water variable based on lwc flag
-    df["LWC"] = df["W"]
+    df["LWC"] = df["LWC"]
     water_var = "LWC" if lwc else "R"
     water_label = "LWC [g/m³]" if lwc else "R [mm/h]"
 
@@ -3731,7 +3750,7 @@ 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})
+    dims_to_drop = set(ds.dims).intersection({DIAMETER_DIMENSION, VELOCITY_DIMENSION, "crs"})
     # - Drop array variables and convert to pandas
     df = ds.drop_dims(dims_to_drop).to_pandas()
     # - Drop coordinates
@@ -3742,7 +3761,7 @@ def create_l2_dataframe(ds):
     return df
 
 
-def prepare_summary_dataset(ds, velocity_method="fall_velocity", source="drop_number"):
+def prepare_summary_dataset(ds, velocity_method="theoretical_velocity", source="drop_number"):
     """Prepare the L2E or L2M dataset to be converted to a dataframe."""
     # Select fall velocity method
     if "velocity_method" in ds.dims:
@@ -3783,8 +3802,11 @@ 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]
+    # Filter dataset to remove noisy timesteps
+    # - Keep only timesteps with at least 3 Nbins to remove noise
+    # - Keep only timesteps with sigma_m >= 0.2
+    mask = (ds["Nbins"] >= 3) & (ds["sigma_m"] >= 0.2) & (ds["Nbins_missing_fraction"] <= 0.3) & (ds["Dmin"] <= 1)
+    valid_idx = np.where(mask)[0]
     ds = ds.isel(time=valid_idx)
 
     ####---------------------------------------------------------------------.
@@ -3795,7 +3817,10 @@ def generate_station_summary(ds, summary_dir_path, data_source, campaign_name, s
         drop_number = ds["drop_number"].sum(dim="time")
 
         # Define theoretical and measured average velocity
-        theoretical_average_velocity = ds["fall_velocity"].mean(dim="time")
+        if "time" in ds["fall_velocity"].dims:
+            theoretical_average_velocity = ds["fall_velocity"].mean(dim="time")
+        else:
+            theoretical_average_velocity = ds["fall_velocity"]
         measured_average_velocity = get_drop_average_velocity(drop_number)
 
         # Save raw and filtered spectrum over time & theoretical and measured average fall velocity
@@ -3909,6 +3934,7 @@ def generate_station_summary(ds, summary_dir_path, data_source, campaign_name, s
             table_events_summary.to_csv(table_events_summary_csv_filepath)
             # - Save table as pdf
             if is_latex_engine_available():
+                # Sorted by time
                 table_events_summary_pdf_filename = table_events_summary_csv_filename.replace(".csv", ".pdf")
                 table_events_summary_pdf_filepath = os.path.join(summary_dir_path, table_events_summary_pdf_filename)
                 save_table_to_pdf(
@@ -3919,6 +3945,45 @@ def generate_station_summary(ds, summary_dir_path, data_source, campaign_name, s
                     orientation="landscape",
                 )
 
+                # Sorted by maximum rain intensity
+                table_events_summary = table_events_summary.sort_values(by="max_R", ascending=False)
+                table_events_summary = table_events_summary.reset_index(drop=True)
+                table_events_summary_pdf_filename = define_filename(
+                    prefix="Events_Summary_Sorted_By_Rmax",
+                    extension="pdf",
+                    data_source=data_source,
+                    campaign_name=campaign_name,
+                    station_name=station_name,
+                    temporal_resolution=temporal_resolution,
+                )
+                table_events_summary_pdf_filepath = os.path.join(summary_dir_path, table_events_summary_pdf_filename)
+                save_table_to_pdf(
+                    df=prepare_latex_table_events_summary(table_events_summary),
+                    filepath=table_events_summary_pdf_filepath,
+                    index=True,
+                    caption="Events Summary",
+                    orientation="landscape",
+                )
+                # Sorted by Ptotal
+                table_events_summary = table_events_summary.sort_values(by="P_total", ascending=False)
+                table_events_summary = table_events_summary.reset_index(drop=True)
+                table_events_summary_pdf_filename = define_filename(
+                    prefix="Events_Summary_Sorted_By_Ptot",
+                    extension="pdf",
+                    data_source=data_source,
+                    campaign_name=campaign_name,
+                    station_name=station_name,
+                    temporal_resolution=temporal_resolution,
+                )
+                table_events_summary_pdf_filepath = os.path.join(summary_dir_path, table_events_summary_pdf_filename)
+                save_table_to_pdf(
+                    df=prepare_latex_table_events_summary(table_events_summary),
+                    filepath=table_events_summary_pdf_filepath,
+                    index=True,
+                    caption="Events Summary",
+                    orientation="landscape",
+                )
+
     # ---------------------------------------------------------------------.
     #### Create table with integral DSD parameters statistics
     table_dsd_summary = create_table_dsd_summary(df)

disdrodb/utils/__init__.py

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

disdrodb/utils/archiving.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Utility function for DISDRODB product archiving."""
+
 import datetime
 
 import numpy as np
@@ -111,17 +112,18 @@ def generate_time_blocks(
 def identify_events(
     filepaths,
     parallel=False,
-    min_drops=5,
+    variable="N",
+    detection_threshold=5,
     neighbor_min_size=2,
     neighbor_time_interval="5MIN",
     event_max_time_gap="6H",
     event_min_duration="5MIN",
     event_min_size=3,
 ):
-    """Return a list of rainy events.
+    """Return a list of precipitating events.
 
-    Rainy timesteps are defined when N > min_drops.
-    Any rainy isolated timesteps (based on neighborhood criteria) is removed.
+    Precipitating events are defined when 'variable' > detection_threshold.
+    Any isolated timesteps with precipitation (based on neighborhood criteria) is removed.
     Then, consecutive rainy timesteps are grouped into the same event if the time gap between them does not
     exceed `event_max_time_gap`. Finally, events that do not meet minimum size or duration
     requirements are filtered out.
@@ -130,6 +132,11 @@ def identify_events(
     ----------
     filepaths: list
         List of L1C file paths.
+    variable : str
+        Name of the variable to use to apply the event detection.
+        The default is "N".
+    detection_threshold : int
+        Minimum value of 'variable' to consider an event timestep.
     parallel: bool
         Whether to load the files in parallel.
         Set parallel=True only in a multiprocessing environment.
@@ -163,11 +170,11 @@ def identify_events(
         - "n_timesteps": int, number of valid timesteps in the event
     """
     # Open datasets in parallel
-    ds = open_netcdf_files(filepaths, variables=["time", "N"], parallel=parallel, compute=True)
+    ds = open_netcdf_files(filepaths, variables=["time", variable], parallel=parallel, compute=True)
     # Sort dataset by time
     ds = ensure_sorted_by_time(ds)
     # Define candidate timesteps to group into events
-    idx_valid = ds["N"].to_numpy() > min_drops
+    idx_valid = ds[variable].to_numpy() > detection_threshold
     timesteps = ds["time"].to_numpy()[idx_valid]
     if "sample_interval" in ds:
         sample_interval = ds["sample_interval"].compute().item()
@@ -263,8 +270,9 @@ def define_temporal_partitions(filepaths, strategy, parallel, strategy_options):
         See identify_time_partitions for more information.
 
         If ``strategy == 'event'``, supported options are:
-
-        - ``min_drops`` : int
+        - ``variable`` : str
+          Name of the variable to use to apply the event detection.
+        - ``detection_threshold`` : int
           Minimum number of drops to consider a timestep.
         - ``neighbor_min_size`` : int
           Minimum cluster size for merging neighboring events.
@@ -317,7 +325,7 @@ def _map_files_to_blocks(files_start_time, files_end_time, filepaths, block_star
     # Create a list with the a dictionary for each block
     filepaths = np.array(filepaths)
     results = []
-    for i, (start, end) in enumerate(zip(block_starts, block_ends)):
+    for i, (start, end) in enumerate(zip(block_starts, block_ends, strict=True)):
         indices = np.where(mask[:, i])[0]
         if indices.size > 0:
             results.append(

disdrodb/utils/attrs.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,9 +15,10 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """DISDRODB netCDF4 attributes utilities."""
-import datetime
+
 import os
 
+from disdrodb.api.checks import get_current_utc_time
 from disdrodb.constants import ARCHIVE_VERSION, CONVENTIONS, COORDINATES, SOFTWARE_VERSION
 from disdrodb.utils.yaml import read_yaml
 
@@ -95,15 +94,18 @@ def update_disdrodb_attrs(ds, product: str):
     # ----------------------------------------------
     # Add time_coverage_start and time_coverage_end
     if "time" in ds.dims:
+        encoding = ds["time"].encoding
         ds["time"] = ds["time"].dt.floor("s")  # ensure no sub-second values
         ds["time"] = ds["time"].astype("datetime64[s]")
+        ds["time"].encoding = encoding  # otherwise time encoding get lost !
+
         attrs["time_coverage_start"] = str(ds["time"].data[0])
         attrs["time_coverage_end"] = str(ds["time"].data[-1])
 
     # ----------------------------------------------
     # Set DISDRODDB attributes
     # - Add DISDRODB processing info
-    now = datetime.datetime.utcnow()
+    now = get_current_utc_time()
     current_time = now.strftime("%Y-%m-%d %H:%M:%S")
     attrs["disdrodb_processing_date"] = current_time
     # - Add DISDRODB product and version