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

disdrodb/l0/routines.py

@@ -21,14 +21,13 @@
 import datetime
 import logging
 import os
+import shutil
 import time
 from typing import Optional
 
 import dask
 
-from disdrodb.api.checks import check_sensor_name
-
-# Directory
+from disdrodb.api.checks import check_sensor_name, check_station_inputs
 from disdrodb.api.create_directories import (
     create_l0_directory_structure,
     create_logs_directory,
@@ -41,6 +40,7 @@ from disdrodb.api.path import (
     define_l0b_filename,
     define_l0c_filename,
     define_metadata_filepath,
+    define_partitioning_tree,
 )
 from disdrodb.api.search import get_required_product
 from disdrodb.configs import get_data_archive_dir, get_folder_partitioning, get_metadata_archive_dir
@@ -53,7 +53,7 @@ from disdrodb.l0.l0a_processing import (
 )
 from disdrodb.l0.l0b_nc_processing import sanitize_ds
 from disdrodb.l0.l0b_processing import (
-    create_l0b_from_l0a,
+    generate_l0b,
     set_l0b_encodings,
     write_l0b,
 )
@@ -63,6 +63,7 @@ from disdrodb.l0.l0c_processing import (
     retrieve_possible_measurement_intervals,
 )
 from disdrodb.metadata import read_station_metadata
+from disdrodb.utils.attrs import set_disdrodb_attrs
 from disdrodb.utils.decorators import delayed_if_parallel, single_threaded_if_parallel
 
 # Logger
@@ -73,8 +74,6 @@ from disdrodb.utils.logger import (
     log_error,
     log_info,
 )
-
-# log_warning,
 from disdrodb.utils.writer import write_product
 from disdrodb.utils.yaml import read_yaml
 
@@ -124,7 +123,7 @@ def _generate_l0a(
     # Log start processing
     msg = f"{product} processing of {filename} has started."
     log_info(logger=logger, msg=msg, verbose=verbose)
-
+    success_flag = False
     ##------------------------------------------------------------------------.
     ### - Read raw file into a dataframe and sanitize for L0A format
     try:
@@ -144,6 +143,12 @@ def _generate_l0a(
         filepath = os.path.join(folder_path, filename)
         write_l0a(df=df, filepath=filepath, force=force, logger=logger, verbose=verbose)
 
+        ##--------------------------------------------------------------------.
+        #### - Define logger file final directory
+        if folder_partitioning != "":
+            log_dst_dir = define_file_folder_path(df, data_dir=logs_dir, folder_partitioning=folder_partitioning)
+            os.makedirs(log_dst_dir, exist_ok=True)
+
         ##--------------------------------------------------------------------.
         # Clean environment
         del df
@@ -151,6 +156,7 @@ def _generate_l0a(
         # 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
     except Exception as e:
@@ -161,6 +167,13 @@ def _generate_l0a(
     # 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
 
@@ -200,6 +213,7 @@ def _generate_l0b(
     # Log start processing
     msg = f"{product} processing of {filename} has started."
     log_info(logger=logger, msg=msg, verbose=verbose)
+    success_flag = False
 
     ##------------------------------------------------------------------------.
     # Retrieve sensor name
@@ -209,11 +223,11 @@ def _generate_l0b(
     ##------------------------------------------------------------------------.
     try:
         # Read L0A Apache Parquet file
-        df = read_l0a_dataframe(filepath, logger=logger, verbose=verbose, debugging_mode=debugging_mode)
+        df = read_l0a_dataframe(filepath, debugging_mode=debugging_mode)
 
         # -----------------------------------------------------------------.
         # Create xarray Dataset
-        ds = create_l0b_from_l0a(df=df, metadata=metadata, logger=logger, verbose=verbose)
+        ds = generate_l0b(df=df, metadata=metadata, logger=logger, verbose=verbose)
 
         # -----------------------------------------------------------------.
         # Write L0B netCDF4 dataset
@@ -222,6 +236,12 @@ def _generate_l0b(
         filepath = os.path.join(folder_path, filename)
         write_l0b(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
         del ds, df
@@ -229,6 +249,7 @@ def _generate_l0b(
         # 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
     except Exception as e:
@@ -239,10 +260,19 @@ def _generate_l0b(
     # 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
 
 
+@delayed_if_parallel
+@single_threaded_if_parallel
 def _generate_l0b_from_nc(
     filepath,
     data_dir,
@@ -282,6 +312,7 @@ def _generate_l0b_from_nc(
     # Log start processing
     msg = f"{product} processing of {filename} has started."
     log_info(logger=logger, msg=msg, verbose=verbose)
+    success_flag = False
 
     ##------------------------------------------------------------------------.
     ### - Read raw netCDF and sanitize for L0B format
@@ -303,6 +334,12 @@ def _generate_l0b_from_nc(
         filepath = os.path.join(folder_path, filename)
         write_l0b(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
         del ds
@@ -310,6 +347,7 @@ def _generate_l0b_from_nc(
         # Log end processing
         msg = f"L0B processing of {filename} has ended."
         log_info(logger=logger, msg=msg, verbose=verbose)
+        success_flag = True
 
     # Otherwise log the error
     except Exception as e:
@@ -320,6 +358,13 @@ def _generate_l0b_from_nc(
     # 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
 
@@ -358,6 +403,7 @@ def _generate_l0c(
     # Log start processing
     msg = f"{product} processing for {day} has started."
     log_info(logger=logger, msg=msg, verbose=verbose)
+    success_flag = False
 
     ##------------------------------------------------------------------------.
     ### Core computation
@@ -388,21 +434,35 @@ def _generate_l0c(
 
                 # Set encodings
                 ds = set_l0b_encodings(ds=ds, sensor_name=sensor_name)
+                # Update global attributes
+                ds = set_disdrodb_attrs(ds, product=product)
 
-                # Define filepath
+                # Define product filepath
                 filename = define_l0c_filename(ds, campaign_name=campaign_name, station_name=station_name)
                 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)
 
         # Clean environment
         del ds
 
+        ##--------------------------------------------------------------------.
+        #### - Define logger file final directory
+        if folder_partitioning != "":
+            print(day)
+            dirtree = define_partitioning_tree(
+                time=datetime.datetime.strptime("2022-03-22", "%Y-%m-%d"),
+                folder_partitioning=folder_partitioning,
+            )
+            log_dst_dir = os.path.join(logs_dir, dirtree)
+            os.makedirs(log_dst_dir, exist_ok=True)
+
         # Log end processing
         msg = f"{product} processing for {day} has ended."
         log_info(logger=logger, msg=msg, verbose=verbose)
+        success_flag = True
 
     ##--------------------------------------------------------------------.
     # Otherwise log the error
@@ -414,6 +474,13 @@ def _generate_l0c(
     # 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
 
@@ -474,6 +541,15 @@ def run_l0a_station(
     data_archive_dir = get_data_archive_dir(data_archive_dir)
     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,
+    )
+
+    # ------------------------------------------------------------------------.
     # Read metadata
     metadata = read_station_metadata(
         metadata_archive_dir=metadata_archive_dir,
@@ -652,7 +728,7 @@ def run_l0b_station(
         and multi-threading will be automatically exploited to speed up I/O tasks.
     debugging_mode : bool, optional
         If ``True``, the amount of data processed will be reduced.
-        Only the first 100 rows of 3 L0A files will be processed. The default value is ``False``.
+        Only 100 rows sampled from 3 L0A files will be processed. The default value is ``False``.
     remove_l0a: bool, optional
         Whether to remove the processed L0A files. The default value is ``False``.
     data_archive_dir : str, optional
@@ -669,6 +745,13 @@ def run_l0b_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,
+    )
     # -----------------------------------------------------------------.
     # Retrieve metadata
     metadata = read_station_metadata(
@@ -731,7 +814,7 @@ def run_l0b_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)
@@ -899,6 +982,14 @@ def run_l0c_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,
+    )
+
     # ------------------------------------------------------------------------.
     # Start processing
     t_i = time.time()
@@ -957,7 +1048,7 @@ def run_l0c_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/__init__.py

@@ -15,3 +15,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """DISDRODB L1 module."""
+from disdrodb.l1.processing import generate_l1
+
+__all__ = [
+    "generate_l1",
+]

disdrodb/l1/filters.py

@@ -19,6 +19,8 @@
 import numpy as np
 import xarray as xr
 
+from disdrodb.constants import DIAMETER_DIMENSION, VELOCITY_DIMENSION
+
 
 def filter_diameter_bins(ds, minimum_diameter=None, maximum_diameter=None):
     """
@@ -29,10 +31,10 @@ def filter_diameter_bins(ds, minimum_diameter=None, maximum_diameter=None):
     ds : xarray.Dataset
         The dataset containing diameter bin data.
     minimum_diameter : float, optional
-        The minimum diameter to include in the filter, in millimeters.
+        The minimum diameter to be included, in millimeters.
         Defaults to the minimum value in `ds["diameter_bin_lower"]`.
     maximum_diameter : float, optional
-        The maximum diameter to include in the filter, in millimeters.
+        The maximum diameter to be included, in millimeters.
         Defaults to the maximum value in `ds["diameter_bin_upper"]`.
 
     Returns
@@ -40,22 +42,28 @@ def filter_diameter_bins(ds, minimum_diameter=None, maximum_diameter=None):
     xarray.Dataset
         The filtered dataset containing only the specified diameter bins.
     """
+    # Put data into memory
+    ds["diameter_bin_lower"] = ds["diameter_bin_lower"].compute()
+    ds["diameter_bin_upper"] = ds["diameter_bin_upper"].compute()
+
     # Initialize default arguments
     if minimum_diameter is None:
         minimum_diameter = ds["diameter_bin_lower"].min().item()
     if maximum_diameter is None:
         maximum_diameter = ds["diameter_bin_upper"].max().item()
-    # Select valid bins
+
+    # Select bins which overlap the specified diameters
     valid_indices = np.logical_and(
-        ds["diameter_bin_lower"] >= minimum_diameter,
-        ds["diameter_bin_upper"] <= maximum_diameter,
-    )
-    ds = ds.isel({"diameter_bin_center": valid_indices})
-    # Update history
-    history = ds.attrs.get("history", "")
-    ds.attrs["history"] = (
-        history + f" Selected drops with diameters between {minimum_diameter} and {maximum_diameter} mm \n"
+        ds["diameter_bin_upper"] > minimum_diameter,
+        ds["diameter_bin_lower"] < maximum_diameter,
     )
+
+    # Select bins with diameter values entirely inside the specified min/max values
+    # valid_indices = np.logical_and(
+    #     ds["diameter_bin_lower"] >= minimum_diameter,
+    #     ds["diameter_bin_upper"] <= maximum_diameter,
+    # )
+    ds = ds.isel({DIAMETER_DIMENSION: valid_indices})
     return ds
 
 
@@ -79,22 +87,28 @@ def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
     xarray.Dataset
         The filtered dataset containing only the specified velocity bins.
     """
+    # Put data into memory
+    ds["velocity_bin_lower"] = ds["velocity_bin_lower"].compute()
+    ds["velocity_bin_upper"] = ds["velocity_bin_upper"].compute()
+
     # Initialize default arguments
     if minimum_velocity is None:
         minimum_velocity = ds["velocity_bin_lower"].min().item()
     if maximum_velocity is None:
         maximum_velocity = ds["velocity_bin_upper"].max().item()
-    # Select valid bins
+
+    # Select bins which overlap the specified velocities
     valid_indices = np.logical_and(
-        ds["velocity_bin_lower"] >= minimum_velocity,
-        ds["velocity_bin_upper"] <= maximum_velocity,
-    )
-    ds = ds.isel({"velocity_bin_center": valid_indices})
-    # Update history
-    history = ds.attrs.get("history", "")
-    ds.attrs["history"] = (
-        history + f" Selected drops with fall velocity between {minimum_velocity} and {maximum_velocity} m/s \n"
+        ds["velocity_bin_upper"] > minimum_velocity,
+        ds["velocity_bin_lower"] < maximum_velocity,
     )
+
+    # Select bins with velocity values entirely inside the specified min/max values
+    # valid_indices = np.logical_and(
+    #     ds["velocity_bin_lower"] >= minimum_velocity,
+    #     ds["velocity_bin_upper"] <= maximum_velocity,
+    # )
+    ds = ds.isel({VELOCITY_DIMENSION: valid_indices})
     return ds
 
 

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