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

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,15 +75,26 @@ 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)):
+        return _is_valid_numeric_frequency(frequency)
+    raise TypeError(f"Frequency {frequency} must be a string or a number.")
 
 
 def ensure_numerical_frequency(frequency):
@@ -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):
@@ -973,7 +991,7 @@ def get_radar_parameters(
         list_ds = [func(ds_subset, **params) for params in list_params]
 
     # Merge into a single dataset
-    ds_radar = xr.merge(list_ds)
+    ds_radar = xr.merge(list_ds, compat="no_conflicts", join="outer")
 
     # Order frequency from lowest to highest
     # --> ['S', 'C', 'X', 'Ku', 'K', 'Ka', 'W']

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
@@ -223,6 +223,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 +238,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 +361,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 +376,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 +403,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 +451,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}$",
@@ -716,7 +734,7 @@ def create_nd_dataframe(ds, variables=None):
         "sample_interval",
         *RADAR_OPTIONS,
     ]
-    df_nd = ds_stack.to_dataframe().drop(columns=coords_to_drop, errors="ignore")
+    df_nd = ds_stack.to_dask_dataframe().drop(columns=coords_to_drop, errors="ignore").compute()
     df_nd["D"] = df_nd["diameter_bin_center"]
     df_nd["N(D)"] = df_nd["drop_number_concentration"]
     df_nd = df_nd[df_nd["R"] != 0]
@@ -918,7 +936,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 +945,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 +956,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 +966,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 +1037,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 +1085,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 +1101,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 +1117,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 +1132,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 +1162,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 +1229,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 +1354,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]"
 
@@ -3742,7 +3760,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:
@@ -3789,70 +3807,72 @@ def generate_station_summary(ds, summary_dir_path, data_source, campaign_name, s
 
     ####---------------------------------------------------------------------.
     #### 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")
-
-    # Define theoretical and measured average velocity
-    theoretical_average_velocity = ds["fall_velocity"].mean(dim="time")
-    measured_average_velocity = get_drop_average_velocity(drop_number)
-
-    # Save raw and filtered spectrum over time & theoretical and measured average fall velocity
-    ds_stats = xr.Dataset()
-    ds_stats["raw_drop_number"] = raw_drop_number
-    ds_stats["drop_number"] = raw_drop_number
-    ds_stats["theoretical_average_velocity"] = theoretical_average_velocity
-    ds_stats["measured_average_velocity"] = measured_average_velocity
-    filename = define_filename(
-        prefix="SpectrumStats",
-        extension="nc",
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-        temporal_resolution=temporal_resolution,
-    )
-    ds_stats.to_netcdf(os.path.join(summary_dir_path, filename))
+    if VELOCITY_DIMENSION in ds.dims:
+        # 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")
+
+        # Define theoretical and measured average velocity
+        theoretical_average_velocity = ds["fall_velocity"].mean(dim="time")
+        measured_average_velocity = get_drop_average_velocity(drop_number)
+
+        # Save raw and filtered spectrum over time & theoretical and measured average fall velocity
+        ds_stats = xr.Dataset()
+        ds_stats["raw_drop_number"] = raw_drop_number
+        ds_stats["drop_number"] = raw_drop_number
+        ds_stats["theoretical_average_velocity"] = theoretical_average_velocity
+        if measured_average_velocity is not None:
+            ds_stats["measured_average_velocity"] = measured_average_velocity
+        filename = define_filename(
+            prefix="SpectrumStats",
+            extension="nc",
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            temporal_resolution=temporal_resolution,
+        )
+        ds_stats.to_netcdf(os.path.join(summary_dir_path, filename))
 
-    # Create figures with raw and filtered spectrum
-    # - Raw
-    filename = define_filename(
-        prefix="SpectrumRaw",
-        extension="png",
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-        temporal_resolution=temporal_resolution,
-    )
-    p = plot_spectrum(raw_drop_number, title="Raw Drop Spectrum")
-    p.figure.savefig(os.path.join(summary_dir_path, filename))
-    plt.close()
+        # Create figures with raw and filtered spectrum
+        # - Raw
+        filename = define_filename(
+            prefix="SpectrumRaw",
+            extension="png",
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            temporal_resolution=temporal_resolution,
+        )
+        p = plot_spectrum(raw_drop_number, title="Raw Drop Spectrum")
+        p.figure.savefig(os.path.join(summary_dir_path, filename))
+        plt.close()
 
-    # - Filtered
-    filename = define_filename(
-        prefix="SpectrumFiltered",
-        extension="png",
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-        temporal_resolution=temporal_resolution,
-    )
-    p = plot_spectrum(drop_number, title="Filtered Drop Spectrum")
-    p.figure.savefig(os.path.join(summary_dir_path, filename))
-    plt.close()
+        # - Filtered
+        filename = define_filename(
+            prefix="SpectrumFiltered",
+            extension="png",
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            temporal_resolution=temporal_resolution,
+        )
+        p = plot_spectrum(drop_number, title="Filtered Drop Spectrum")
+        p.figure.savefig(os.path.join(summary_dir_path, filename))
+        plt.close()
 
-    # Create figure comparing raw and filtered spectrum
-    filename = define_filename(
-        prefix="SpectrumSummary",
-        extension="png",
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-        temporal_resolution=temporal_resolution,
-    )
+        # Create figure comparing raw and filtered spectrum
+        filename = define_filename(
+            prefix="SpectrumSummary",
+            extension="png",
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            temporal_resolution=temporal_resolution,
+        )
 
-    fig = plot_raw_and_filtered_spectra(ds)
-    fig.savefig(os.path.join(summary_dir_path, filename))
-    plt.close()
+        fig = plot_raw_and_filtered_spectra(ds)
+        fig.savefig(os.path.join(summary_dir_path, filename))
+        plt.close()
 
     ####---------------------------------------------------------------------.
     #### Create L2E dataframe
@@ -3907,6 +3927,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(
@@ -3917,6 +3938,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
@@ -111,17 +111,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 +131,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 +169,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 +269,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.

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
@@ -95,8 +93,11 @@ 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])