disdrodb 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

disdrodb/l1/processing.py

@@ -16,22 +16,19 @@
 # -----------------------------------------------------------------------------.
 """Core functions for DISDRODB L1 production."""
 
-
 import xarray as xr
 
-from disdrodb import DIAMETER_DIMENSION, VELOCITY_DIMENSION
-from disdrodb.l1.encoding_attrs import get_attrs_dict, get_encoding_dict
+from disdrodb.constants import DIAMETER_DIMENSION, VELOCITY_DIMENSION
 from disdrodb.l1.fall_velocity import get_raindrop_fall_velocity
 from disdrodb.l1.filters import define_spectrum_mask, filter_diameter_bins, filter_velocity_bins
 from disdrodb.l1.resampling import add_sample_interval
 from disdrodb.l1_env.routines import load_env_dataset
 from disdrodb.l2.empirical_dsd import (  # TODO: maybe move out of L2
-    compute_qc_bins_metrics,
+    add_bins_metrics,
     get_min_max_diameter,
 )
-from disdrodb.utils.attrs import set_attrs
-from disdrodb.utils.encoding import set_encodings
 from disdrodb.utils.time import ensure_sample_interval_in_seconds, infer_sample_interval
+from disdrodb.utils.writer import finalize_product
 
 
 def generate_l1(
@@ -51,7 +48,7 @@ def generate_l1(
     small_velocity_threshold=2.5,  # 3
     maintain_smallest_drops=True,
 ):
-    """Generate the DISDRODB L1 dataset from the DISDRODB L0C dataset.
+    """Generate DISDRODB L1 Dataset from DISDRODB L0C Dataset.
 
     Parameters
     ----------
@@ -88,17 +85,17 @@ def generate_l1(
     xarray.Dataset
         DISRODB L1 dataset.
     """
-    # Take as input an L0 !
-
     # Retrieve source attributes
     attrs = ds.attrs.copy()
 
     # Determine if the velocity dimension is available
     has_velocity_dimension = VELOCITY_DIMENSION in ds.dims
 
-    # Initialize L2 dataset
-    ds_l1 = xr.Dataset()
+    # Retrieve sensor_name
+    # - If not present, don't drop Parsivels first two bins
+    sensor_name = attrs.get("sensor_name", "")
 
+    # ---------------------------------------------------------------------------
     # Retrieve sample interval
     # --> sample_interval is a coordinate of L0C products
     if "sample_interval" in ds:
@@ -107,39 +104,52 @@ def generate_l1(
         # This line is not called in the DISDRODB processing chain !
         sample_interval = infer_sample_interval(ds, verbose=False)
 
-    # Re-add sample interval as coordinate (in seconds)
-    ds = add_sample_interval(ds, sample_interval=sample_interval)
-
     # ---------------------------------------------------------------------------
     # Retrieve ENV dataset or take defaults
     # --> Used only for Beard fall velocity currently !
     ds_env = load_env_dataset(ds)
 
+    # ---------------------------------------------------------------------------
+    # Initialize L1 dataset
+    ds_l1 = xr.Dataset()
+
+    # Add raw_drop_number variable to L1 dataset
+    ds_l1["raw_drop_number"] = ds["raw_drop_number"]
+
+    # Add sample interval as coordinate (in seconds)
+    ds_l1 = add_sample_interval(ds_l1, sample_interval=sample_interval)
+
+    # Add L0C coordinates that might got lost
+    if "time_qc" in ds_l1:
+        ds_l1 = ds_l1.assign_coords({"time_qc": ds["time_qc"]})
+
     # -------------------------------------------------------------------------------------------
     # Filter dataset by diameter and velocity bins
+    if sensor_name in ["PARSIVEL", "PARSIVEL2"]:
+        # - Remove first two bins because never reports data !
+        # - If not removed, can alter e.g. L2M model fitting
+        ds_l1 = filter_diameter_bins(ds=ds_l1, minimum_diameter=0.312)  # it includes the 0.2495-0.3745 bin
+
     # - Filter diameter bins
-    ds = filter_diameter_bins(ds=ds, minimum_diameter=minimum_diameter, maximum_diameter=maximum_diameter)
+    ds_l1 = filter_diameter_bins(ds=ds_l1, minimum_diameter=minimum_diameter, maximum_diameter=maximum_diameter)
     # - Filter velocity bins
     if has_velocity_dimension:
-        ds = filter_velocity_bins(ds=ds, minimum_velocity=minimum_velocity, maximum_velocity=maximum_velocity)
+        ds_l1 = filter_velocity_bins(ds=ds_l1, minimum_velocity=minimum_velocity, maximum_velocity=maximum_velocity)
 
     # -------------------------------------------------------------------------------------------
     # Compute fall velocity
-    fall_velocity = get_raindrop_fall_velocity(
-        diameter=ds["diameter_bin_center"],
+    ds_l1["fall_velocity"] = get_raindrop_fall_velocity(
+        diameter=ds_l1["diameter_bin_center"],
         method=fall_velocity_method,
         ds_env=ds_env,  # mm
     )
 
-    # Add fall velocity
-    ds_l1["fall_velocity"] = fall_velocity
-
     # -------------------------------------------------------------------------------------------
     # Define filtering mask according to fall velocity
     if has_velocity_dimension:
         mask = define_spectrum_mask(
-            drop_number=ds["raw_drop_number"],
-            fall_velocity=fall_velocity,
+            drop_number=ds_l1["raw_drop_number"],
+            fall_velocity=ds_l1["fall_velocity"],
             above_velocity_fraction=above_velocity_fraction,
             above_velocity_tolerance=above_velocity_tolerance,
             below_velocity_fraction=below_velocity_fraction,
@@ -152,14 +162,14 @@ def generate_l1(
     # -------------------------------------------------------------------------------------------
     # Retrieve drop number and drop_counts arrays
     if has_velocity_dimension:
-        drop_number = ds["raw_drop_number"].where(mask)  # 2D (diameter, velocity)
+        drop_number = ds_l1["raw_drop_number"].where(mask)  # 2D (diameter, velocity)
         drop_counts = drop_number.sum(dim=VELOCITY_DIMENSION)  # 1D (diameter)
-        drop_counts_raw = ds["raw_drop_number"].sum(dim=VELOCITY_DIMENSION)  # 1D (diameter)
+        drop_counts_raw = ds_l1["raw_drop_number"].sum(dim=VELOCITY_DIMENSION)  # 1D (diameter)
 
     else:
-        drop_number = ds["raw_drop_number"]  # 1D (diameter)
-        drop_counts = ds["raw_drop_number"]  # 1D (diameter)
-        drop_counts_raw = ds["raw_drop_number"]
+        drop_number = ds_l1["raw_drop_number"]  # 1D (diameter)
+        drop_counts = ds_l1["raw_drop_number"]  # 1D (diameter)
+        drop_counts_raw = ds_l1["raw_drop_number"]
 
     # Add drop number and drop_counts
     ds_l1["drop_number"] = drop_number
@@ -173,30 +183,21 @@ def generate_l1(
     ds_l1["Dmin"] = min_drop_diameter
     ds_l1["Dmax"] = max_drop_diameter
     ds_l1["N"] = drop_counts.sum(dim=DIAMETER_DIMENSION)
-    ds_l1["Nremoved"] = drop_counts_raw.sum(dim=DIAMETER_DIMENSION) - ds_l1["N"]
+    ds_l1["Nraw"] = drop_counts_raw.sum(dim=DIAMETER_DIMENSION)
+    ds_l1["Nremoved"] = ds_l1["Nraw"] - ds_l1["N"]
 
     # Add bins statistics
-    ds_l1.update(compute_qc_bins_metrics(ds_l1))
+    ds_l1 = add_bins_metrics(ds_l1)
 
     # -------------------------------------------------------------------------------------------
     # Add quality flags
     # TODO: snow_flags, insects_flag, ...
 
-    # -------------------------------------------------------------------------------------------
-    #### Add L0C coordinates that might got lost
-    if "time_qc" in ds:
-        ds_l1 = ds_l1.assign_coords({"time_qc": ds["time_qc"]})
-
     #### ----------------------------------------------------------------------------.
-    #### Add encodings and attributes
-    # Add variables attributes
-    attrs_dict = get_attrs_dict()
-    ds_l1 = set_attrs(ds_l1, attrs_dict=attrs_dict)
-
-    # Add variables encoding
-    encoding_dict = get_encoding_dict()
-    ds_l1 = set_encodings(ds_l1, encoding_dict=encoding_dict)
-
+    #### Finalize dataset
     # Add global attributes
     ds_l1.attrs = attrs
+
+    # Add variables attributes and encodings
+    ds_l1 = finalize_product(ds_l1, product="L1")
     return ds_l1

disdrodb/l1/resampling.py

@@ -15,12 +15,11 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Utilities for temporal resampling."""
-
-
+import numpy as np
 import pandas as pd
 import xarray as xr
 
-from disdrodb.utils.time import regularize_dataset
+from disdrodb.utils.time import ensure_sample_interval_in_seconds, regularize_dataset
 
 DEFAULT_ACCUMULATIONS = ["10s", "30s", "1min", "2min", "5min", "10min", "30min", "1hour"]
 
@@ -96,6 +95,24 @@ def define_window_size(sample_interval, accumulation_interval):
     return window_size
 
 
+def _resample(ds, variables, accumulation, op):
+    if not variables:
+        return {}
+    ds_subset = ds[variables]
+    if "time" in ds_subset.dims:
+        return getattr(ds_subset.resample({"time": accumulation}), op)(skipna=False)
+    return ds_subset
+
+
+def _rolling(ds, variables, window_size, op):
+    if not variables:
+        return {}
+    ds_subset = ds[variables]
+    if "time" in ds_subset.dims:
+        return getattr(ds_subset.rolling(time=window_size, center=False), op)(skipna=False)
+    return ds_subset
+
+
 def resample_dataset(ds, sample_interval, accumulation_interval, rolling=True):
     """
     Resample the dataset to a specified accumulation interval.
@@ -128,20 +145,61 @@ def resample_dataset(ds, sample_interval, accumulation_interval, rolling=True):
     - The function updates the dataset attributes and the sample_interval coordinate.
 
     """
-    # Retrieve attributes
-    attrs = ds.attrs.copy()
-
-    # TODO: here infill NaN with zero if necessary before regularizing !
+    # --------------------------------------------------------------------------.
+    # Ensure sample interval in seconds
+    sample_interval = int(ensure_sample_interval_in_seconds(sample_interval))
+
+    # --------------------------------------------------------------------------.
+    # Raise error if the accumulation_interval is less than the sample interval
+    if accumulation_interval < sample_interval:
+        raise ValueError("Expecting an accumulation_interval > sample interval.")
+    # Raise error if accumulation_interval is not multiple of sample_interval
+    if not accumulation_interval % sample_interval == 0:
+        raise ValueError("The accumulation_interval is not a multiple of sample interval.")
+
+    # --------------------------------------------------------------------------.
+    #### Preprocess the dataset
+    # Here we set NaN in the raw_drop_number to 0
+    # - We assume that NaN corresponds to 0
+    # - When we regularize, we infill with NaN
+    # - When we aggregate with sum, we don't skip NaN
+    # --> Aggregation with original missing timesteps currently results in NaN !
+
+    # Infill NaN values with zeros for drop_number and raw_drop_number
+    # - This might alter integrated statistics if NaN in spectrum does not actually correspond to 0 !
+    # - TODO: NaN should not be set as 0 !
+    for var in ["drop_number", "raw_drop_number"]:
+        if var in ds:
+            ds[var] = xr.where(np.isnan(ds[var]), 0, ds[var])
 
     # Ensure regular dataset without missing timesteps
+    # --> This adds NaN values for missing timesteps
     ds = regularize_dataset(ds, freq=f"{sample_interval}s")
 
+    # --------------------------------------------------------------------------.
+    # Define dataset attributes
+    attrs = ds.attrs.copy()
+    if rolling:
+        attrs["disdrodb_rolled_product"] = "True"
+    else:
+        attrs["disdrodb_rolled_product"] = "False"
+
+    if sample_interval == accumulation_interval:
+        attrs["disdrodb_aggregated_product"] = "False"
+        ds = add_sample_interval(ds, sample_interval=accumulation_interval)
+        ds.attrs = attrs
+        return ds
+
+    # --------------------------------------------------------------------------.
+    # Resample the dataset
+    attrs["disdrodb_aggregated_product"] = "True"
+
     # Initialize resample dataset
     ds_resampled = xr.Dataset()
 
     # Retrieve variables to average/sum
     var_to_average = ["fall_velocity"]
-    var_to_cumulate = ["raw_drop_number", "drop_number", "drop_counts", "N", "Nremoved"]
+    var_to_cumulate = ["raw_drop_number", "drop_number", "drop_counts", "N", "Nraw", "Nremoved"]
     var_to_min = ["Dmin"]
     var_to_max = ["Dmax"]
 
@@ -154,6 +212,7 @@ def resample_dataset(ds, sample_interval, accumulation_interval, rolling=True):
     # TODO Define custom processing
     # - quality_flag --> take worst
     # - skipna if less than fraction (to not waste lot of data when aggregating over i.e. hours)
+    # - Add tolerance on fraction of missing timesteps for large accumulation_intervals
 
     # Resample the dataset
     # - Rolling currently does not allow direct rolling forward.
@@ -163,74 +222,26 @@ def resample_dataset(ds, sample_interval, accumulation_interval, rolling=True):
     # - https://github.com/pydata/xarray/issues/8958
     if not rolling:
         # Resample
-        if len(var_to_average) > 0:
-            ds_resampled.update(
-                ds[var_to_average].resample({"time": pd.Timedelta(seconds=accumulation_interval)}).mean(skipna=False),
-            )
-        if len(var_to_cumulate) > 0:
-            ds_resampled.update(
-                ds[var_to_cumulate].resample({"time": pd.Timedelta(seconds=accumulation_interval)}).sum(skipna=False),
-            )
-        if len(var_to_min) > 0:
-            ds_resampled.update(
-                ds[var_to_min].resample({"time": pd.Timedelta(seconds=accumulation_interval)}).min(skipna=False),
-            )
-        if len(var_to_max) > 0:
-            ds_resampled.update(
-                ds[var_to_max].resample({"time": pd.Timedelta(seconds=accumulation_interval)}).max(skipna=False),
-            )
-
+        accumulation = pd.Timedelta(seconds=accumulation_interval)
+        ds_resampled.update(_resample(ds=ds, variables=var_to_average, accumulation=accumulation, op="mean"))
+        ds_resampled.update(_resample(ds=ds, variables=var_to_cumulate, accumulation=accumulation, op="sum"))
+        ds_resampled.update(_resample(ds=ds, variables=var_to_min, accumulation=accumulation, op="min"))
+        ds_resampled.update(_resample(ds=ds, variables=var_to_max, accumulation=accumulation, op="max"))
     else:
         # Roll and Resample
         window_size = define_window_size(sample_interval=sample_interval, accumulation_interval=accumulation_interval)
-        if len(var_to_average) > 0:
-            ds_resampled.update(ds[var_to_average].rolling({"time": window_size}, center=False).mean(skipna=False))
-        if len(var_to_cumulate) > 0:
-            ds_resampled.update(ds[var_to_cumulate].rolling({"time": window_size}, center=False).sum(skipna=False))
-
-        if len(var_to_min) > 0:
-            ds_resampled.update(ds[var_to_min].rolling({"time": window_size}, center=False).min(skipna=False))
-        if len(var_to_max) > 0:
-            ds_resampled.update(ds[var_to_max].rolling({"time": window_size}, center=False).max(skipna=False))
-        # Ensure time to correspond to the start time of the integration
+        ds_resampled.update(_rolling(ds=ds, variables=var_to_average, window_size=window_size, op="mean"))
+        ds_resampled.update(_rolling(ds=ds, variables=var_to_cumulate, window_size=window_size, op="sum"))
+        ds_resampled.update(_rolling(ds=ds, variables=var_to_min, window_size=window_size, op="min"))
+        ds_resampled.update(_rolling(ds=ds, variables=var_to_max, window_size=window_size, op="max"))
+        # Ensure time to correspond to the start time of the measurement period
         ds_resampled = ds_resampled.isel(time=slice(window_size - 1, None)).assign_coords(
             {"time": ds_resampled["time"].data[: -window_size + 1]},
         )
 
     # Add attributes
     ds_resampled.attrs = attrs
-    if rolling:
-        ds_resampled.attrs["rolled"] = "True"
-    else:
-        ds_resampled.attrs["rolled"] = "False"
 
     # Add accumulation_interval as new sample_interval coordinate
     ds_resampled = add_sample_interval(ds_resampled, sample_interval=accumulation_interval)
     return ds_resampled
-
-
-def get_possible_accumulations(sample_interval, accumulations=None):
-    """
-    Get a list of valid accumulation intervals based on the sampling time.
-
-    Parameters
-    ----------
-    - sample_interval (int): The inferred sampling time in seconds.
-    - accumulations (list of int or string): List of desired accumulation intervals.
-    If provide integers, specify accumulation in seconds.
-
-    Returns
-    -------
-    - list of int: Valid accumulation intervals in seconds.
-    """
-    # Select default accumulations
-    if accumulations is None:
-        accumulations = DEFAULT_ACCUMULATIONS
-
-    # Get accumulations in seconds
-    accumulations = [int(pd.Timedelta(acc).total_seconds()) if isinstance(acc, str) else acc for acc in accumulations]
-
-    # Filter candidate accumulations to include only those that are multiples of the sampling time
-    possible_accumulations = [acc for acc in accumulations if acc % sample_interval == 0]
-
-    return possible_accumulations

disdrodb/l1/routines.py

@@ -21,13 +21,14 @@
 import datetime
 import logging
 import os
+import shutil
 import time
 from typing import Optional
 
 import dask
 import xarray as xr
 
-# Directory
+from disdrodb.api.checks import check_station_inputs
 from disdrodb.api.create_directories import (
     create_logs_directory,
     create_product_directory,
@@ -38,7 +39,12 @@ from disdrodb.api.path import (
     define_l1_filename,
 )
 from disdrodb.api.search import get_required_product
-from disdrodb.configs import get_data_archive_dir, get_folder_partitioning, get_metadata_archive_dir
+from disdrodb.configs import (
+    get_data_archive_dir,
+    get_folder_partitioning,
+    get_metadata_archive_dir,
+    get_product_options,
+)
 from disdrodb.l1.processing import generate_l1
 from disdrodb.utils.decorators import delayed_if_parallel, single_threaded_if_parallel
 
@@ -55,41 +61,6 @@ from disdrodb.utils.writer import write_product
 logger = logging.getLogger(__name__)
 
 
-def get_l1_options():
-    """Get L1 options."""
-    # - TODO: from YAML
-    # - TODO: as function of sensor name
-
-    # minimum_diameter
-    # --> PWS100: 0.05
-    # --> PARSIVEL: 0.2495
-    # --> RD80: 0.313
-    # --> LPM: 0.125 (we currently discard first bin with this setting)
-
-    # maximum_diameter
-    # LPM: 8 mm
-    # RD80: 5.6 mm
-    # OTT: 26 mm
-
-    l1_options = {
-        # Fall velocity option
-        "fall_velocity_method": "Beard1976",
-        # Diameter-Velocity Filtering Options
-        "minimum_diameter": 0.2495,  # OTT PARSIVEL first two bin no data !
-        "maximum_diameter": 10,
-        "minimum_velocity": 0,
-        "maximum_velocity": 12,
-        "above_velocity_fraction": 0.5,
-        "above_velocity_tolerance": None,
-        "below_velocity_fraction": 0.5,
-        "below_velocity_tolerance": None,
-        "small_diameter_threshold": 1,  # 2
-        "small_velocity_threshold": 2.5,  # 3
-        "maintain_smallest_drops": True,
-    }
-    return l1_options
-
-
 @delayed_if_parallel
 @single_threaded_if_parallel
 def _generate_l1(
@@ -152,16 +123,16 @@ def _generate_l1(
     # Log start processing
     msg = f"{product} processing of {filename} has started."
     log_info(logger=logger, msg=msg, verbose=verbose)
-
+    success_flag = False
     ##------------------------------------------------------------------------.
     # Retrieve L1 configurations
-    l1_options = get_l1_options()
+    l1_options = get_product_options("L1").get("product_options")
 
     ##------------------------------------------------------------------------.
     ### Core computation
     try:
         # Open the raw netCDF
-        with xr.open_dataset(filepath, chunks={}, decode_timedelta=False, cache=False) as ds:
+        with xr.open_dataset(filepath, chunks=-1, decode_timedelta=False, cache=False) as ds:
             ds = ds[["raw_drop_number"]].load()
 
         # Produce L1 dataset
@@ -174,7 +145,13 @@ def _generate_l1(
             folder_path = define_file_folder_path(ds, data_dir=data_dir, folder_partitioning=folder_partitioning)
             filepath = os.path.join(folder_path, filename)
             # Write to disk
-            write_product(ds, product=product, filepath=filepath, force=force)
+            write_product(ds, filepath=filepath, force=force)
+
+        ##--------------------------------------------------------------------.
+        #### - Define logger file final directory
+        if folder_partitioning != "":
+            log_dst_dir = define_file_folder_path(ds, data_dir=logs_dir, folder_partitioning=folder_partitioning)
+            os.makedirs(log_dst_dir, exist_ok=True)
 
         ##--------------------------------------------------------------------.
         # Clean environment
@@ -183,6 +160,7 @@ def _generate_l1(
         # Log end processing
         msg = f"{product} processing of {filename} has ended."
         log_info(logger=logger, msg=msg, verbose=verbose)
+        success_flag = True
 
     ##--------------------------------------------------------------------.
     # Otherwise log the error
@@ -194,6 +172,13 @@ def _generate_l1(
     # Close the file logger
     close_logger(logger)
 
+    # Move logger file to correct partitioning directory
+    if success_flag and folder_partitioning != "" and logger_filepath is not None:
+        # Move logger file to correct partitioning directory
+        dst_filepath = os.path.join(log_dst_dir, os.path.basename(logger_filepath))
+        shutil.move(logger_filepath, dst_filepath)
+        logger_filepath = dst_filepath
+
     # Return the logger file path
     return logger_filepath
 
@@ -259,6 +244,14 @@ def run_l1_station(
     # Retrieve DISDRODB Metadata Archive directory
     metadata_archive_dir = get_metadata_archive_dir(metadata_archive_dir)
 
+    # Check valid data_source, campaign_name, and station_name
+    check_station_inputs(
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+    )
+
     # Define logs directory
     logs_dir = create_logs_directory(
         product=product,
@@ -309,7 +302,7 @@ def run_l1_station(
     # If no data available, print error message and return None
     if flag_not_available_data:
         msg = (
-            f"{product} processing of {data_source} {campaign_name} {station_name}"
+            f"{product} processing of {data_source} {campaign_name} {station_name} "
             + f"has not been launched because of missing {required_product} data."
         )
         print(msg)

disdrodb/l1_env/routines.py

@@ -15,9 +15,10 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Core functions for DISDRODB ENV production."""
-
 import xarray as xr
 
+from disdrodb.constants import GEOLOCATION_COORDS
+
 
 def get_default_environment_dataset():
     """Define defaults values for the ENV dataset."""
@@ -30,9 +31,23 @@ def get_default_environment_dataset():
     return ds_env
 
 
+def _assign_geolocation(ds_src, dst_dst):
+
+    dict_coords = {coord: ds_src[coord] for coord in GEOLOCATION_COORDS if coord in ds_src}
+    dst_dst = dst_dst.assign_coords(dict_coords)
+    return dst_dst
+
+
 def load_env_dataset(ds):
     """Load the ENV dataset."""
-    # TODO - Retrieve relative_humidity and temperature from L1-ENV
+    # TODO: Retrieve relative_humidity and temperature from L1-ENV
     ds_env = get_default_environment_dataset()
-    ds_env = ds_env.assign_coords({"altitude": ds["altitude"], "latitude": ds["latitude"]})
+    # Compute water density
+    # get_water_density(
+    # temperature=temperature,
+    # air_pressure=air_pressure,
+    # )
+    # -->  (T == 10 --> 999.7, T == 20 --> 998.2
+    ds_env["water_density"] = 1000  # kg / m3 # TODO as function of ENV (temperature, ...) ?
+    ds_env = _assign_geolocation(ds_src=ds, dst_dst=ds_env)
     return ds_env

disdrodb/l2/__init__.py

@@ -15,3 +15,10 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Module for DISDRODB L2 production."""
+from disdrodb.l2.processing import generate_l2_radar, generate_l2e, generate_l2m
+
+__all__ = [
+    "generate_l2_radar",
+    "generate_l2e",
+    "generate_l2m",
+]